Fix API paths and add missing settings

- Fix PHP syntax error in auto-screenshot.php (cron comment)
- Change fetch paths from absolute /api/ to relative api/
- Add missing settings to settings.json (weekly_timelapse_enabled, auto_screenshot, sharing)

HealthBridge/App/HealthBridgeApp.swift

@@ -0,0 +1,91 @@
+import SwiftUI
+import HealthKit
+import BackgroundTasks
+
+@main
+struct HealthBridgeApp: App {
+    @StateObject private var appState = AppState()
+    @StateObject private var healthKitManager = HealthKitManager.shared
+    @StateObject private var syncCoordinator = SyncCoordinator.shared
+
+    init() {
+        registerBackgroundTasks()
+    }
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+                .environmentObject(appState)
+                .environmentObject(healthKitManager)
+                .environmentObject(syncCoordinator)
+                .onAppear {
+                    Task {
+                        await requestHealthKitAuthorization()
+                    }
+                }
+        }
+    }
+
+    private func registerBackgroundTasks() {
+        BGTaskScheduler.shared.register(
+            forTaskWithIdentifier: "com.healthbridge.sync",
+            using: nil
+        ) { task in
+            guard let bgTask = task as? BGAppRefreshTask else { return }
+            handleBackgroundSync(task: bgTask)
+        }
+    }
+
+    private func handleBackgroundSync(task: BGAppRefreshTask) {
+        scheduleNextBackgroundSync()
+
+        let syncTask = Task {
+            do {
+                try await syncCoordinator.performSync()
+                task.setTaskCompleted(success: true)
+            } catch {
+                task.setTaskCompleted(success: false)
+            }
+        }
+
+        task.expirationHandler = {
+            syncTask.cancel()
+        }
+    }
+
+    private func scheduleNextBackgroundSync() {
+        let request = BGAppRefreshTaskRequest(identifier: "com.healthbridge.sync")
+        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60) // 15 min
+
+        do {
+            try BGTaskScheduler.shared.submit(request)
+        } catch {
+            print("Failed to schedule background sync: \(error)")
+        }
+    }
+
+    private func requestHealthKitAuthorization() async {
+        do {
+            try await healthKitManager.requestAuthorization()
+        } catch {
+            print("HealthKit authorization failed: \(error)")
+        }
+    }
+}
+
+// MARK: - App State
+@MainActor
+class AppState: ObservableObject {
+    @Published var selectedTab: Tab = .dashboard
+    @Published var showingConflictDetail: Conflict?
+    @Published var isLoading = false
+    @Published var lastSyncDate: Date?
+    @Published var pendingConflicts: [Conflict] = []
+
+    enum Tab {
+        case dashboard
+        case conflicts
+        case rules
+        case sources
+    }
+}

HealthBridge/Models/Conflict.swift

@@ -0,0 +1,315 @@
+import Foundation
+
+// MARK: - Conflict
+struct Conflict: Identifiable, Codable {
+    let id: UUID
+    let dataType: HealthDataType
+    let timeWindow: TimeWindow
+    var readings: [SourceReading]
+    var status: ConflictStatus
+    var resolution: ConflictResolution?
+    var appliedStrategy: MergeStrategy?
+    let detectedAt: Date
+    var resolvedAt: Date?
+
+    init(
+        id: UUID = UUID(),
+        dataType: HealthDataType,
+        timeWindow: TimeWindow,
+        readings: [SourceReading],
+        status: ConflictStatus = .pending,
+        resolution: ConflictResolution? = nil,
+        appliedStrategy: MergeStrategy? = nil,
+        detectedAt: Date = Date(),
+        resolvedAt: Date? = nil
+    ) {
+        self.id = id
+        self.dataType = dataType
+        self.timeWindow = timeWindow
+        self.readings = readings
+        self.status = status
+        self.resolution = resolution
+        self.appliedStrategy = appliedStrategy
+        self.detectedAt = detectedAt
+        self.resolvedAt = resolvedAt
+    }
+
+    var valueDifference: Double {
+        guard readings.count >= 2 else { return 0 }
+        let values = readings.map { $0.value }
+        return (values.max() ?? 0) - (values.min() ?? 0)
+    }
+
+    var percentageDifference: Double {
+        guard readings.count >= 2 else { return 0 }
+        let values = readings.map { $0.value }
+        guard let min = values.min(), min > 0 else { return 0 }
+        guard let max = values.max() else { return 0 }
+        return ((max - min) / min) * 100
+    }
+
+    var severity: ConflictSeverity {
+        let pctDiff = percentageDifference
+        if pctDiff < 5 { return .minor }
+        if pctDiff < 20 { return .moderate }
+        if pctDiff < 50 { return .significant }
+        return .major
+    }
+
+    var highestValueReading: SourceReading? {
+        readings.max(by: { $0.value < $1.value })
+    }
+
+    var lowestValueReading: SourceReading? {
+        readings.min(by: { $0.value < $1.value })
+    }
+
+    var primarySourceReading: SourceReading? {
+        readings.max(by: { $0.sourceCategory.priority < $1.sourceCategory.priority })
+    }
+}
+
+// MARK: - Conflict Status
+enum ConflictStatus: String, Codable {
+    case pending = "pending"
+    case resolved = "resolved"
+    case manualReview = "manual_review"
+    case ignored = "ignored"
+
+    var displayName: String {
+        switch self {
+        case .pending: return "Offen"
+        case .resolved: return "Gelöst"
+        case .manualReview: return "Manuelle Prüfung"
+        case .ignored: return "Ignoriert"
+        }
+    }
+
+    var icon: String {
+        switch self {
+        case .pending: return "clock.fill"
+        case .resolved: return "checkmark.circle.fill"
+        case .manualReview: return "hand.raised.fill"
+        case .ignored: return "eye.slash.fill"
+        }
+    }
+}
+
+// MARK: - Conflict Severity
+enum ConflictSeverity: String, Codable {
+    case minor = "minor"
+    case moderate = "moderate"
+    case significant = "significant"
+    case major = "major"
+
+    var displayName: String {
+        switch self {
+        case .minor: return "Gering"
+        case .moderate: return "Moderat"
+        case .significant: return "Erheblich"
+        case .major: return "Gross"
+        }
+    }
+
+    var color: String {
+        switch self {
+        case .minor: return "green"
+        case .moderate: return "yellow"
+        case .significant: return "orange"
+        case .major: return "red"
+        }
+    }
+}
+
+// MARK: - Conflict Resolution
+struct ConflictResolution: Codable {
+    let resolvedValue: Double
+    let secondaryResolvedValue: Double? // For blood pressure
+    let winningSourceId: String
+    let strategy: MergeStrategy
+    let isManual: Bool
+    let resolvedAt: Date
+    let notes: String?
+
+    init(
+        resolvedValue: Double,
+        secondaryResolvedValue: Double? = nil,
+        winningSourceId: String,
+        strategy: MergeStrategy,
+        isManual: Bool = false,
+        resolvedAt: Date = Date(),
+        notes: String? = nil
+    ) {
+        self.resolvedValue = resolvedValue
+        self.secondaryResolvedValue = secondaryResolvedValue
+        self.winningSourceId = winningSourceId
+        self.strategy = strategy
+        self.isManual = isManual
+        self.resolvedAt = resolvedAt
+        self.notes = notes
+    }
+}
+
+// MARK: - Merge Strategy
+enum MergeStrategy: String, Codable, CaseIterable, Identifiable {
+    case exclusive = "exclusive"
+    case priority = "priority"
+    case higherWins = "higher_wins"
+    case lowerWins = "lower_wins"
+    case average = "average"
+    case coverage = "coverage"
+    case coverageThenHigher = "coverage_then_higher"
+    case manual = "manual"
+    case mostRecent = "most_recent"
+
+    var id: String { rawValue }
+
+    var displayName: String {
+        switch self {
+        case .exclusive: return "Exklusiv"
+        case .priority: return "Priorität"
+        case .higherWins: return "Höherer Wert"
+        case .lowerWins: return "Niedrigerer Wert"
+        case .average: return "Durchschnitt"
+        case .coverage: return "Abdeckung"
+        case .coverageThenHigher: return "Abdeckung + Höher"
+        case .manual: return "Manuell"
+        case .mostRecent: return "Neuester"
+        }
+    }
+
+    var description: String {
+        switch self {
+        case .exclusive:
+            return "Nur eine Quelle kann diesen Datentyp liefern"
+        case .priority:
+            return "Höchste Priorität gewinnt basierend auf Benutzereinstellungen"
+        case .higherWins:
+            return "Der grössere Wert wird verwendet (z.B. mehr Schritte = war aktiv)"
+        case .lowerWins:
+            return "Der kleinere Wert wird verwendet"
+        case .average:
+            return "Durchschnitt aller Quellen"
+        case .coverage:
+            return "Quelle mit Daten für dieses Zeitfenster"
+        case .coverageThenHigher:
+            return "Erst Abdeckung prüfen, dann höherer Wert bei Konflikt"
+        case .manual:
+            return "Benutzer entscheidet bei jedem Konflikt"
+        case .mostRecent:
+            return "Zuletzt erfasster Wert"
+        }
+    }
+
+    var icon: String {
+        switch self {
+        case .exclusive: return "1.circle.fill"
+        case .priority: return "list.number"
+        case .higherWins: return "arrow.up.circle.fill"
+        case .lowerWins: return "arrow.down.circle.fill"
+        case .average: return "divide.circle.fill"
+        case .coverage: return "square.fill.on.square.fill"
+        case .coverageThenHigher: return "square.stack.3d.up.fill"
+        case .manual: return "hand.raised.fill"
+        case .mostRecent: return "clock.arrow.circlepath"
+        }
+    }
+}
+
+// MARK: - Merge Rule
+struct MergeRule: Identifiable, Codable {
+    let id: UUID
+    let dataType: HealthDataType
+    var strategy: MergeStrategy
+    var primarySourceId: String?
+    var fallbackSourceId: String?
+    var sourcePriorities: [String: Int]
+    var autoApply: Bool
+    var thresholdForManualReview: Double? // Percentage difference threshold
+
+    init(
+        id: UUID = UUID(),
+        dataType: HealthDataType,
+        strategy: MergeStrategy,
+        primarySourceId: String? = nil,
+        fallbackSourceId: String? = nil,
+        sourcePriorities: [String: Int] = [:],
+        autoApply: Bool = true,
+        thresholdForManualReview: Double? = nil
+    ) {
+        self.id = id
+        self.dataType = dataType
+        self.strategy = strategy
+        self.primarySourceId = primarySourceId
+        self.fallbackSourceId = fallbackSourceId
+        self.sourcePriorities = sourcePriorities
+        self.autoApply = autoApply
+        self.thresholdForManualReview = thresholdForManualReview
+    }
+
+    static func defaultRule(for dataType: HealthDataType) -> MergeRule {
+        switch dataType {
+        case .bloodPressureSystolic, .bloodPressureDiastolic, .bloodOxygen,
+             .heartRate, .restingHeartRate, .heartRateVariability, .respiratoryRate:
+            return MergeRule(dataType: dataType, strategy: .exclusive)
+        case .floorsClimbed:
+            return MergeRule(dataType: dataType, strategy: .exclusive)
+        case .steps, .distance, .activeEnergy:
+            return MergeRule(dataType: dataType, strategy: .coverageThenHigher)
+        case .sleep:
+            return MergeRule(dataType: dataType, strategy: .priority)
+        }
+    }
+}
+
+// MARK: - Sync Record
+struct SyncRecord: Identifiable, Codable {
+    let id: UUID
+    let dataType: HealthDataType
+    let timeWindow: TimeWindow
+    var readings: [SourceReading]
+    var mergedValue: Double?
+    var secondaryMergedValue: Double? // For blood pressure
+    var strategy: MergeStrategy
+    var status: SyncStatus
+    var hasConflict: Bool
+    var conflictId: UUID?
+    let createdAt: Date
+    var processedAt: Date?
+
+    enum SyncStatus: String, Codable {
+        case pending = "pending"
+        case processing = "processing"
+        case completed = "completed"
+        case failed = "failed"
+        case requiresManualReview = "requires_manual"
+    }
+
+    init(
+        id: UUID = UUID(),
+        dataType: HealthDataType,
+        timeWindow: TimeWindow,
+        readings: [SourceReading],
+        mergedValue: Double? = nil,
+        secondaryMergedValue: Double? = nil,
+        strategy: MergeStrategy = .priority,
+        status: SyncStatus = .pending,
+        hasConflict: Bool = false,
+        conflictId: UUID? = nil,
+        createdAt: Date = Date(),
+        processedAt: Date? = nil
+    ) {
+        self.id = id
+        self.dataType = dataType
+        self.timeWindow = timeWindow
+        self.readings = readings
+        self.mergedValue = mergedValue
+        self.secondaryMergedValue = secondaryMergedValue
+        self.strategy = strategy
+        self.status = status
+        self.hasConflict = hasConflict
+        self.conflictId = conflictId
+        self.createdAt = createdAt
+        self.processedAt = processedAt
+    }
+}

HealthBridge/Models/HealthDataTypes.swift

@@ -0,0 +1,269 @@
+import Foundation
+import HealthKit
+
+// MARK: - Health Data Type
+enum HealthDataType: String, CaseIterable, Codable, Identifiable {
+    case steps = "steps"
+    case heartRate = "heart_rate"
+    case bloodPressureSystolic = "blood_pressure_systolic"
+    case bloodPressureDiastolic = "blood_pressure_diastolic"
+    case bloodOxygen = "blood_oxygen"
+    case sleep = "sleep"
+    case distance = "distance"
+    case floorsClimbed = "floors_climbed"
+    case activeEnergy = "active_energy"
+    case restingHeartRate = "resting_heart_rate"
+    case heartRateVariability = "hrv"
+    case respiratoryRate = "respiratory_rate"
+
+    var id: String { rawValue }
+
+    var displayName: String {
+        switch self {
+        case .steps: return "Schritte"
+        case .heartRate: return "Herzfrequenz"
+        case .bloodPressureSystolic: return "Blutdruck (Systolisch)"
+        case .bloodPressureDiastolic: return "Blutdruck (Diastolisch)"
+        case .bloodOxygen: return "Blutsauerstoff (SpO2)"
+        case .sleep: return "Schlaf"
+        case .distance: return "Distanz"
+        case .floorsClimbed: return "Stockwerke"
+        case .activeEnergy: return "Aktive Energie"
+        case .restingHeartRate: return "Ruhepuls"
+        case .heartRateVariability: return "HRV"
+        case .respiratoryRate: return "Atemfrequenz"
+        }
+    }
+
+    var icon: String {
+        switch self {
+        case .steps: return "figure.walk"
+        case .heartRate, .restingHeartRate: return "heart.fill"
+        case .bloodPressureSystolic, .bloodPressureDiastolic: return "drop.fill"
+        case .bloodOxygen: return "lungs.fill"
+        case .sleep: return "bed.double.fill"
+        case .distance: return "map.fill"
+        case .floorsClimbed: return "stairs"
+        case .activeEnergy: return "flame.fill"
+        case .heartRateVariability: return "waveform.path.ecg"
+        case .respiratoryRate: return "wind"
+        }
+    }
+
+    var unit: String {
+        switch self {
+        case .steps: return "Schritte"
+        case .heartRate, .restingHeartRate: return "bpm"
+        case .bloodPressureSystolic, .bloodPressureDiastolic: return "mmHg"
+        case .bloodOxygen: return "%"
+        case .sleep: return "h"
+        case .distance: return "km"
+        case .floorsClimbed: return "Stockwerke"
+        case .activeEnergy: return "kcal"
+        case .heartRateVariability: return "ms"
+        case .respiratoryRate: return "/min"
+        }
+    }
+
+    var hkQuantityType: HKQuantityType? {
+        switch self {
+        case .steps:
+            return HKQuantityType.quantityType(forIdentifier: .stepCount)
+        case .heartRate:
+            return HKQuantityType.quantityType(forIdentifier: .heartRate)
+        case .bloodPressureSystolic:
+            return HKQuantityType.quantityType(forIdentifier: .bloodPressureSystolic)
+        case .bloodPressureDiastolic:
+            return HKQuantityType.quantityType(forIdentifier: .bloodPressureDiastolic)
+        case .bloodOxygen:
+            return HKQuantityType.quantityType(forIdentifier: .oxygenSaturation)
+        case .distance:
+            return HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning)
+        case .floorsClimbed:
+            return HKQuantityType.quantityType(forIdentifier: .flightsClimbed)
+        case .activeEnergy:
+            return HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)
+        case .restingHeartRate:
+            return HKQuantityType.quantityType(forIdentifier: .restingHeartRate)
+        case .heartRateVariability:
+            return HKQuantityType.quantityType(forIdentifier: .heartRateVariabilitySDNN)
+        case .respiratoryRate:
+            return HKQuantityType.quantityType(forIdentifier: .respiratoryRate)
+        case .sleep:
+            return nil // Sleep uses category type
+        }
+    }
+
+    var hkCategoryType: HKCategoryType? {
+        switch self {
+        case .sleep:
+            return HKCategoryType.categoryType(forIdentifier: .sleepAnalysis)
+        default:
+            return nil
+        }
+    }
+
+    var hkUnit: HKUnit {
+        switch self {
+        case .steps, .floorsClimbed:
+            return .count()
+        case .heartRate, .restingHeartRate, .respiratoryRate:
+            return HKUnit.count().unitDivided(by: .minute())
+        case .bloodPressureSystolic, .bloodPressureDiastolic:
+            return .millimeterOfMercury()
+        case .bloodOxygen:
+            return .percent()
+        case .sleep:
+            return .hour()
+        case .distance:
+            return .meterUnit(with: .kilo)
+        case .activeEnergy:
+            return .kilocalorie()
+        case .heartRateVariability:
+            return .secondUnit(with: .milli)
+        }
+    }
+
+    /// Default primary source for this data type
+    var defaultPrimarySource: SourceCategory {
+        switch self {
+        case .floorsClimbed:
+            return .iPhone
+        case .steps, .heartRate, .bloodPressureSystolic, .bloodPressureDiastolic,
+             .bloodOxygen, .sleep, .distance, .activeEnergy, .restingHeartRate,
+             .heartRateVariability, .respiratoryRate:
+            return .watch
+        }
+    }
+
+    /// Whether this data type typically has only one source
+    var isExclusive: Bool {
+        switch self {
+        case .bloodPressureSystolic, .bloodPressureDiastolic, .bloodOxygen,
+             .heartRate, .restingHeartRate, .heartRateVariability, .respiratoryRate, .sleep:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+// MARK: - Source Category
+enum SourceCategory: String, Codable, CaseIterable {
+    case iPhone = "iphone"
+    case watch = "watch"
+    case thirdPartyWatch = "third_party_watch"
+    case thirdPartyApp = "third_party_app"
+    case healthBridge = "health_bridge"
+    case unknown = "unknown"
+
+    var displayName: String {
+        switch self {
+        case .iPhone: return "iPhone"
+        case .watch: return "Apple Watch"
+        case .thirdPartyWatch: return "Drittanbieter-Watch"
+        case .thirdPartyApp: return "Drittanbieter-App"
+        case .healthBridge: return "HealthBridge"
+        case .unknown: return "Unbekannt"
+        }
+    }
+
+    var icon: String {
+        switch self {
+        case .iPhone: return "iphone"
+        case .watch: return "applewatch"
+        case .thirdPartyWatch: return "applewatch.side.right"
+        case .thirdPartyApp: return "app.badge"
+        case .healthBridge: return "arrow.triangle.2.circlepath"
+        case .unknown: return "questionmark.circle"
+        }
+    }
+
+    var priority: Int {
+        switch self {
+        case .healthBridge: return 100
+        case .watch: return 80
+        case .thirdPartyWatch: return 70
+        case .iPhone: return 50
+        case .thirdPartyApp: return 30
+        case .unknown: return 0
+        }
+    }
+}
+
+// MARK: - Data Quality
+enum DataQuality: String, Codable {
+    case complete = "complete"
+    case partial = "partial"
+    case missing = "missing"
+    case invalid = "invalid"
+
+    var icon: String {
+        switch self {
+        case .complete: return "checkmark.circle.fill"
+        case .partial: return "circle.lefthalf.filled"
+        case .missing: return "circle.dashed"
+        case .invalid: return "xmark.circle.fill"
+        }
+    }
+
+    var color: String {
+        switch self {
+        case .complete: return "green"
+        case .partial: return "yellow"
+        case .missing: return "gray"
+        case .invalid: return "red"
+        }
+    }
+}
+
+// MARK: - Time Window
+struct TimeWindow: Codable, Hashable, Identifiable {
+    let start: Date
+    let end: Date
+
+    var id: String { "\(start.timeIntervalSince1970)-\(end.timeIntervalSince1970)" }
+
+    var interval: DateInterval {
+        DateInterval(start: start, end: end)
+    }
+
+    var duration: TimeInterval {
+        end.timeIntervalSince(start)
+    }
+
+    var formattedRange: String {
+        let formatter = DateFormatter()
+        formatter.dateStyle = .none
+        formatter.timeStyle = .short
+        return "\(formatter.string(from: start)) - \(formatter.string(from: end))"
+    }
+
+    var formattedDate: String {
+        let formatter = DateFormatter()
+        formatter.dateStyle = .medium
+        formatter.timeStyle = .none
+        return formatter.string(from: start)
+    }
+
+    static func windows(for date: Date, intervalMinutes: Int = 15) -> [TimeWindow] {
+        let calendar = Calendar.current
+        let startOfDay = calendar.startOfDay(for: date)
+        let endOfDay = calendar.date(byAdding: .day, value: 1, to: startOfDay)!
+
+        var windows: [TimeWindow] = []
+        var current = startOfDay
+
+        while current < endOfDay {
+            let windowEnd = calendar.date(byAdding: .minute, value: intervalMinutes, to: current)!
+            windows.append(TimeWindow(start: current, end: min(windowEnd, endOfDay)))
+            current = windowEnd
+        }
+
+        return windows
+    }
+
+    static func hourlyWindows(for date: Date) -> [TimeWindow] {
+        windows(for: date, intervalMinutes: 60)
+    }
+}

HealthBridge/Models/Source.swift

@@ -0,0 +1,183 @@
+import Foundation
+import HealthKit
+
+// MARK: - Health Source
+struct HealthSource: Identifiable, Codable, Hashable {
+    let id: String
+    let bundleIdentifier: String
+    let name: String
+    let category: SourceCategory
+    var supportedDataTypes: Set<HealthDataType>
+    var lastActivityDate: Date?
+    var userPriorities: [HealthDataType: Int]
+    var isEnabled: Bool
+
+    init(
+        id: String = UUID().uuidString,
+        bundleIdentifier: String,
+        name: String,
+        category: SourceCategory,
+        supportedDataTypes: Set<HealthDataType> = [],
+        lastActivityDate: Date? = nil,
+        userPriorities: [HealthDataType: Int] = [:],
+        isEnabled: Bool = true
+    ) {
+        self.id = id
+        self.bundleIdentifier = bundleIdentifier
+        self.name = name
+        self.category = category
+        self.supportedDataTypes = supportedDataTypes
+        self.lastActivityDate = lastActivityDate
+        self.userPriorities = userPriorities
+        self.isEnabled = isEnabled
+    }
+
+    var displayName: String {
+        if name.isEmpty {
+            return bundleIdentifier.components(separatedBy: ".").last ?? bundleIdentifier
+        }
+        return name
+    }
+
+    var isHealthBridge: Bool {
+        bundleIdentifier == HealthBridgeConstants.bundleIdentifier
+    }
+
+    func priority(for dataType: HealthDataType) -> Int {
+        userPriorities[dataType] ?? category.priority
+    }
+
+    static func from(hkSource: HKSource) -> HealthSource {
+        let category = classifySource(bundleId: hkSource.bundleIdentifier)
+        return HealthSource(
+            id: hkSource.bundleIdentifier,
+            bundleIdentifier: hkSource.bundleIdentifier,
+            name: hkSource.name,
+            category: category
+        )
+    }
+
+    private static func classifySource(bundleId: String) -> SourceCategory {
+        let lowercased = bundleId.lowercased()
+
+        if lowercased.contains("healthbridge") {
+            return .healthBridge
+        } else if lowercased.contains("apple.health") {
+            return .iPhone
+        } else if lowercased.contains("watch") || lowercased.contains("applewatch") {
+            return .watch
+        } else if lowercased.contains("huawei") || lowercased.contains("samsung") ||
+                  lowercased.contains("fitbit") || lowercased.contains("garmin") ||
+                  lowercased.contains("polar") || lowercased.contains("withings") {
+            return .thirdPartyWatch
+        } else {
+            return .thirdPartyApp
+        }
+    }
+}
+
+// MARK: - Source Reading
+struct SourceReading: Identifiable, Codable {
+    let id: UUID
+    let sourceId: String
+    let sourceName: String
+    let sourceCategory: SourceCategory
+    let value: Double
+    let secondaryValue: Double? // For blood pressure (diastolic)
+    let timestamp: Date
+    let originalRecordId: String?
+    let quality: DataQuality
+
+    init(
+        id: UUID = UUID(),
+        sourceId: String,
+        sourceName: String,
+        sourceCategory: SourceCategory,
+        value: Double,
+        secondaryValue: Double? = nil,
+        timestamp: Date,
+        originalRecordId: String? = nil,
+        quality: DataQuality = .complete
+    ) {
+        self.id = id
+        self.sourceId = sourceId
+        self.sourceName = sourceName
+        self.sourceCategory = sourceCategory
+        self.value = value
+        self.secondaryValue = secondaryValue
+        self.timestamp = timestamp
+        self.originalRecordId = originalRecordId
+        self.quality = quality
+    }
+
+    var formattedValue: String {
+        if value == floor(value) {
+            return String(format: "%.0f", value)
+        }
+        return String(format: "%.1f", value)
+    }
+}
+
+// MARK: - Source Health Status
+struct SourceHealthStatus: Identifiable {
+    let id: String
+    let source: HealthSource
+    let lastSync: Date?
+    let recordCount: Int
+    let dataGaps: [TimeWindow]
+    let overallQuality: DataQuality
+
+    var syncStatus: SyncStatus {
+        guard let lastSync = lastSync else {
+            return .neverSynced
+        }
+
+        let hoursSinceSync = Date().timeIntervalSince(lastSync) / 3600
+
+        if hoursSinceSync < 1 {
+            return .recentlySynced
+        } else if hoursSinceSync < 24 {
+            return .syncedToday
+        } else if hoursSinceSync < 72 {
+            return .stale
+        } else {
+            return .veryStale
+        }
+    }
+
+    enum SyncStatus {
+        case recentlySynced
+        case syncedToday
+        case stale
+        case veryStale
+        case neverSynced
+
+        var icon: String {
+            switch self {
+            case .recentlySynced: return "checkmark.circle.fill"
+            case .syncedToday: return "checkmark.circle"
+            case .stale: return "exclamationmark.circle"
+            case .veryStale: return "exclamationmark.triangle"
+            case .neverSynced: return "xmark.circle"
+            }
+        }
+
+        var description: String {
+            switch self {
+            case .recentlySynced: return "Kürzlich synchronisiert"
+            case .syncedToday: return "Heute synchronisiert"
+            case .stale: return "Sync überfällig"
+            case .veryStale: return "Lange nicht synchronisiert"
+            case .neverSynced: return "Nie synchronisiert"
+            }
+        }
+    }
+}
+
+// MARK: - Constants
+enum HealthBridgeConstants {
+    static let bundleIdentifier = "com.healthbridge.merged"
+    static let displayName = "HealthBridge"
+    static let defaultSyncInterval: TimeInterval = 15 * 60 // 15 minutes
+    static let conflictThreshold: TimeInterval = 60 // 1 minute overlap tolerance
+}

HealthBridge/README.md

@@ -0,0 +1,140 @@
+# HealthBridge
+
+Intelligente Health-Daten-Synchronisation für iOS – Eine "Single Source of Truth" für Gesundheitsdaten.
+
+## Übersicht
+
+HealthBridge liest alle Quellen aus Apple Health, erkennt Konflikte zwischen verschiedenen Geräten und Apps, merged intelligent basierend auf konfigurierbaren Regeln und schreibt bereinigte Daten zurück.
+
+## Features
+
+### Source Discovery
+- Automatische Erkennung aller verbundenen Datenquellen
+- Klassifizierung nach Gerätetyp (iPhone, Apple Watch, Drittanbieter-Watch, Apps)
+- Übersicht über Fähigkeiten und unterstützte Datentypen pro Quelle
+
+### Konflikt-Erkennung
+- Automatische Erkennung von Datenkonflikten zwischen Quellen
+- Zeitfenster-basierte Analyse (15-Minuten-Intervalle)
+- Schweregrad-Klassifizierung (minor, moderate, significant, major)
+
+### Merge-Strategien
+- **Exclusive**: Nur eine Quelle möglich (z.B. Blutdruck, SpO2)
+- **Priority**: Fixe Rangfolge basierend auf Benutzereinstellungen
+- **Higher Wins**: Grösserer Wert gewinnt (ideal für Schritte)
+- **Coverage**: Quelle mit Daten für Zeitfenster gewinnt
+- **Coverage Then Higher**: Erst Abdeckung, dann höherer Wert
+- **Average**: Durchschnitt aller Quellen
+- **Manual**: Benutzer entscheidet bei jedem Konflikt
+
+### UI-Komponenten
+- **Dashboard**: Tagesübersicht aller Gesundheitsdaten mit Sync-Status
+- **Konflikte**: Liste offener Konflikte mit One-Tap-Auflösung
+- **Regeln**: Konfiguration der Merge-Strategien pro Datentyp
+- **Quellen**: Übersicht aller erkannten Datenquellen
+
+### Background Sync
+- Automatische Synchronisierung im Hintergrund
+- Konfigurierbares Intervall (15 Min bis 2 Stunden)
+- Push-Benachrichtigungen bei neuen Konflikten
+
+## Unterstützte Datentypen
+
+| Datentyp | Primärquelle | Strategie |
+|----------|--------------|-----------|
+| Schritte | Watch | Coverage + Higher |
+| Herzfrequenz | Watch | Exclusive |
+| Blutdruck | Watch D2 | Exclusive |
+| SpO2 | Watch | Exclusive |
+| Schlaf | Watch | Priority |
+| Distanz | Watch/iPhone | Coverage + Higher |
+| Stockwerke | iPhone | Exclusive |
+| Aktive Energie | Watch | Coverage + Higher |
+
+## Architektur
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        Apple Health                             │
+└─────────────────────────────────────────────────────────────────┘
+                              ▲
+                              │
+┌─────────────────────────────────────────────────────────────────┐
+│                      HealthBridge App                           │
+│                                                                 │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
+│  │ DataReader  │→ │ MergeEngine │→ │ DataWriter  │            │
+│  └─────────────┘  └─────────────┘  └─────────────┘            │
+│         ▲               ▲                                      │
+│  ┌─────────────┐  ┌─────────────┐                             │
+│  │SourceManager│  │ RuleEngine  │                             │
+│  └─────────────┘  └─────────────┘                             │
+│                                                                │
+│  ┌─────────────────────────────────────────────────────────┐  │
+│  │                   SyncCoordinator                        │  │
+│  └─────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Projektstruktur
+
+```
+HealthBridge/
+├── App/
+│   └── HealthBridgeApp.swift      # App-Entry, Background Tasks
+├── Models/
+│   ├── HealthDataTypes.swift      # Datentypen, TimeWindow
+│   ├── Source.swift               # HealthSource, SourceReading
+│   └── Conflict.swift             # Conflict, MergeStrategy, MergeRule
+├── Services/
+│   ├── HealthKitManager.swift     # HealthKit-Integration
+│   ├── SourceManager.swift        # Source Discovery & Management
+│   ├── DataReader.swift           # Daten lesen, Konflikte erkennen
+│   ├── RuleEngine.swift           # Merge-Regeln verwalten & anwenden
+│   ├── MergeEngine.swift          # Konflikte analysieren & lösen
+│   ├── DataWriter.swift           # Daten zurückschreiben
+│   └── SyncCoordinator.swift      # Orchestrierung aller Services
+├── Views/
+│   ├── ContentView.swift          # Tab-Navigation
+│   ├── DashboardView.swift        # Hauptübersicht
+│   ├── ConflictsView.swift        # Konflikt-Liste & Detail
+│   ├── RulesView.swift            # Regelwerk-Editor
+│   ├── SourcesView.swift          # Quellen-Übersicht
+│   ├── SettingsView.swift         # Einstellungen
+│   └── Components/
+│       └── HealthChart.swift      # Diagramm-Komponenten
+├── ViewModels/
+│   └── DashboardViewModel.swift   # Dashboard-Logik
+├── Utils/
+│   ├── Extensions.swift           # Swift-Erweiterungen
+│   └── NotificationManager.swift  # Push-Benachrichtigungen
+└── Resources/
+    ├── Info.plist                 # App-Konfiguration
+    └── HealthBridge.entitlements  # HealthKit-Berechtigungen
+```
+
+## Voraussetzungen
+
+- iOS 16.0+
+- Xcode 15.0+
+- Apple Developer Account (für HealthKit-Entitlements)
+- Physisches Gerät (HealthKit nicht im Simulator verfügbar)
+
+## Installation
+
+1. Projekt in Xcode öffnen
+2. Team für Code Signing auswählen
+3. HealthKit-Capability aktivieren
+4. Auf physischem Gerät ausführen
+
+## Berechtigungen
+
+Die App benötigt folgende Berechtigungen:
+- **HealthKit Read**: Lesen aller Gesundheitsdaten
+- **HealthKit Write**: Schreiben gemergter Daten
+- **Background App Refresh**: Für automatische Synchronisierung
+- **Notifications**: Für Konflikt-Benachrichtigungen
+
+## Lizenz
+
+MIT License

HealthBridge/Resources/HealthBridge.entitlements

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.developer.healthkit</key>
+    <true/>
+    <key>com.apple.developer.healthkit.access</key>
+    <array>
+        <string>health-records</string>
+    </array>
+    <key>com.apple.developer.healthkit.background-delivery</key>
+    <true/>
+    <key>aps-environment</key>
+    <string>development</string>
+</dict>
+</plist>

HealthBridge/Resources/Info.plist

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleDisplayName</key>
+    <string>HealthBridge</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>LSRequiresIPhoneOS</key>
+    <true/>
+    <key>UIApplicationSceneManifest</key>
+    <dict>
+        <key>UIApplicationSupportsMultipleScenes</key>
+        <false/>
+    </dict>
+    <key>UILaunchScreen</key>
+    <dict>
+        <key>UIColorName</key>
+        <string>LaunchScreenBackground</string>
+        <key>UIImageName</key>
+        <string>LaunchIcon</string>
+    </dict>
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+    <key>UISupportedInterfaceOrientations~ipad</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationPortraitUpsideDown</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+    <key>UIRequiredDeviceCapabilities</key>
+    <array>
+        <string>armv7</string>
+        <string>healthkit</string>
+    </array>
+
+    <!-- HealthKit -->
+    <key>NSHealthShareUsageDescription</key>
+    <string>HealthBridge benötigt Zugriff auf Ihre Gesundheitsdaten, um diese zwischen verschiedenen Quellen zu synchronisieren und Konflikte zu lösen.</string>
+    <key>NSHealthUpdateUsageDescription</key>
+    <string>HealthBridge schreibt bereinigte Gesundheitsdaten zurück in Apple Health, um eine konsistente Datenbasis zu gewährleisten.</string>
+
+    <!-- Background Modes -->
+    <key>UIBackgroundModes</key>
+    <array>
+        <string>fetch</string>
+        <string>processing</string>
+    </array>
+    <key>BGTaskSchedulerPermittedIdentifiers</key>
+    <array>
+        <string>com.healthbridge.sync</string>
+        <string>com.healthbridge.cleanup</string>
+    </array>
+</dict>
+</plist>

HealthBridge/Services/DataReader.swift

@@ -0,0 +1,488 @@
+import Foundation
+import HealthKit
+import Combine
+
+// MARK: - Data Reader
+@MainActor
+class DataReader: ObservableObject {
+    static let shared = DataReader()
+
+    private let healthKitManager = HealthKitManager.shared
+    private let sourceManager = SourceManager.shared
+
+    @Published var isReading = false
+    @Published var lastReadDate: Date?
+    @Published var detectedConflicts: [Conflict] = []
+    @Published var readingProgress: Double = 0
+
+    private init() {}
+
+    // MARK: - Fetch Data by Type and Date Range
+
+    func fetchData(
+        for dataType: HealthDataType,
+        from startDate: Date,
+        to endDate: Date,
+        groupByWindow intervalMinutes: Int = 15
+    ) async throws -> [TimeWindowData] {
+        isReading = true
+        defer { isReading = false }
+
+        let samples = try await healthKitManager.fetchSamples(
+            for: dataType,
+            from: startDate,
+            to: endDate
+        )
+
+        // Group samples by source
+        let groupedBySource = groupBySource(samples: samples, dataType: dataType)
+
+        // Create time windows
+        let windows = generateTimeWindows(from: startDate, to: endDate, intervalMinutes: intervalMinutes)
+
+        // Assign samples to windows
+        var windowDataList: [TimeWindowData] = []
+
+        for window in windows {
+            let windowData = createWindowData(
+                window: window,
+                dataType: dataType,
+                groupedBySource: groupedBySource
+            )
+            windowDataList.append(windowData)
+        }
+
+        lastReadDate = Date()
+        return windowDataList
+    }
+
+    private func groupBySource(samples: [HKSample], dataType: HealthDataType) -> [String: [HKSample]] {
+        var grouped: [String: [HKSample]] = [:]
+
+        for sample in samples {
+            let sourceId = sample.sourceRevision.source.bundleIdentifier
+            if grouped[sourceId] == nil {
+                grouped[sourceId] = []
+            }
+            grouped[sourceId]?.append(sample)
+        }
+
+        return grouped
+    }
+
+    private func generateTimeWindows(from start: Date, to end: Date, intervalMinutes: Int) -> [TimeWindow] {
+        var windows: [TimeWindow] = []
+        var current = start
+
+        while current < end {
+            let windowEnd = min(
+                Calendar.current.date(byAdding: .minute, value: intervalMinutes, to: current)!,
+                end
+            )
+            windows.append(TimeWindow(start: current, end: windowEnd))
+            current = windowEnd
+        }
+
+        return windows
+    }
+
+    private func createWindowData(
+        window: TimeWindow,
+        dataType: HealthDataType,
+        groupedBySource: [String: [HKSample]]
+    ) -> TimeWindowData {
+        var readings: [SourceReading] = []
+
+        for (sourceId, samples) in groupedBySource {
+            let windowSamples = samples.filter { sample in
+                sample.startDate < window.end && sample.endDate > window.start
+            }
+
+            if !windowSamples.isEmpty {
+                let reading = createReading(
+                    from: windowSamples,
+                    sourceId: sourceId,
+                    dataType: dataType,
+                    window: window
+                )
+                readings.append(reading)
+            }
+        }
+
+        let hasConflict = detectConflict(in: readings, dataType: dataType)
+
+        return TimeWindowData(
+            timeWindow: window,
+            dataType: dataType,
+            readings: readings,
+            hasConflict: hasConflict
+        )
+    }
+
+    private func createReading(
+        from samples: [HKSample],
+        sourceId: String,
+        dataType: HealthDataType,
+        window: TimeWindow
+    ) -> SourceReading {
+        let value: Double
+        var secondaryValue: Double? = nil
+
+        switch dataType {
+        case .steps, .floorsClimbed, .activeEnergy, .distance:
+            // Sum up values for cumulative types
+            value = samples.compactMap { sample -> Double? in
+                guard let quantitySample = sample as? HKQuantitySample else { return nil }
+                return quantitySample.quantity.doubleValue(for: dataType.hkUnit)
+            }.reduce(0, +)
+
+        case .heartRate, .restingHeartRate, .respiratoryRate, .heartRateVariability, .bloodOxygen:
+            // Average for rate-based types
+            let values = samples.compactMap { sample -> Double? in
+                guard let quantitySample = sample as? HKQuantitySample else { return nil }
+                return quantitySample.quantity.doubleValue(for: dataType.hkUnit)
+            }
+            value = values.isEmpty ? 0 : values.reduce(0, +) / Double(values.count)
+
+        case .bloodPressureSystolic, .bloodPressureDiastolic:
+            // For blood pressure, we need to handle correlations
+            let values = samples.compactMap { sample -> Double? in
+                guard let quantitySample = sample as? HKQuantitySample else { return nil }
+                return quantitySample.quantity.doubleValue(for: dataType.hkUnit)
+            }
+            value = values.isEmpty ? 0 : values.reduce(0, +) / Double(values.count)
+
+        case .sleep:
+            // Sum up sleep duration
+            value = samples.reduce(0) { acc, sample in
+                acc + sample.endDate.timeIntervalSince(sample.startDate) / 3600
+            }
+        }
+
+        let source = sourceManager.sources.first { $0.bundleIdentifier == sourceId }
+        let category = source?.category ?? sourceManager.classifySource(sourceId)
+
+        return SourceReading(
+            sourceId: sourceId,
+            sourceName: source?.name ?? sourceId,
+            sourceCategory: category,
+            value: value,
+            secondaryValue: secondaryValue,
+            timestamp: window.start,
+            originalRecordId: samples.first?.uuid.uuidString,
+            quality: samples.isEmpty ? .missing : .complete
+        )
+    }
+
+    // MARK: - Conflict Detection
+
+    private func detectConflict(in readings: [SourceReading], dataType: HealthDataType) -> Bool {
+        // No conflict if less than 2 readings
+        guard readings.count >= 2 else { return false }
+
+        // Filter out zero values (device wasn't tracking)
+        let nonZeroReadings = readings.filter { $0.value > 0 }
+        guard nonZeroReadings.count >= 2 else { return false }
+
+        // Check if values differ significantly
+        let values = nonZeroReadings.map { $0.value }
+        guard let minVal = values.min(), let maxVal = values.max() else { return false }
+
+        // Threshold varies by data type
+        let threshold = conflictThreshold(for: dataType)
+
+        if minVal == 0 {
+            return maxVal > threshold.absoluteThreshold
+        }
+
+        let percentDiff = (maxVal - minVal) / minVal * 100
+        return percentDiff > threshold.percentageThreshold
+    }
+
+    private func conflictThreshold(for dataType: HealthDataType) -> ConflictThreshold {
+        switch dataType {
+        case .steps:
+            return ConflictThreshold(percentageThreshold: 10, absoluteThreshold: 100)
+        case .distance:
+            return ConflictThreshold(percentageThreshold: 10, absoluteThreshold: 0.1) // 100m
+        case .heartRate:
+            return ConflictThreshold(percentageThreshold: 15, absoluteThreshold: 10)
+        case .bloodPressureSystolic, .bloodPressureDiastolic:
+            return ConflictThreshold(percentageThreshold: 5, absoluteThreshold: 5)
+        case .bloodOxygen:
+            return ConflictThreshold(percentageThreshold: 2, absoluteThreshold: 2)
+        case .floorsClimbed:
+            return ConflictThreshold(percentageThreshold: 20, absoluteThreshold: 2)
+        case .activeEnergy:
+            return ConflictThreshold(percentageThreshold: 15, absoluteThreshold: 50)
+        case .sleep:
+            return ConflictThreshold(percentageThreshold: 10, absoluteThreshold: 0.5) // 30 min
+        case .restingHeartRate:
+            return ConflictThreshold(percentageThreshold: 10, absoluteThreshold: 5)
+        case .heartRateVariability:
+            return ConflictThreshold(percentageThreshold: 20, absoluteThreshold: 10)
+        case .respiratoryRate:
+            return ConflictThreshold(percentageThreshold: 15, absoluteThreshold: 2)
+        }
+    }
+
+    // MARK: - Detect All Conflicts
+
+    func detectConflicts(
+        for date: Date,
+        dataTypes: [HealthDataType] = HealthDataType.allCases
+    ) async throws -> [Conflict] {
+        let calendar = Calendar.current
+        let startOfDay = calendar.startOfDay(for: date)
+        let endOfDay = calendar.date(byAdding: .day, value: 1, to: startOfDay)!
+
+        var allConflicts: [Conflict] = []
+
+        for (index, dataType) in dataTypes.enumerated() {
+            readingProgress = Double(index) / Double(dataTypes.count)
+
+            do {
+                let windowData = try await fetchData(
+                    for: dataType,
+                    from: startOfDay,
+                    to: endOfDay
+                )
+
+                let conflicts = windowData
+                    .filter { $0.hasConflict }
+                    .map { data in
+                        Conflict(
+                            dataType: dataType,
+                            timeWindow: data.timeWindow,
+                            readings: data.readings,
+                            status: .pending
+                        )
+                    }
+
+                allConflicts.append(contentsOf: conflicts)
+            } catch {
+                print("Failed to detect conflicts for \(dataType): \(error)")
+            }
+        }
+
+        readingProgress = 1.0
+        detectedConflicts = allConflicts
+        return allConflicts
+    }
+
+    // MARK: - Data Gaps Detection
+
+    func detectGaps(
+        for dataType: HealthDataType,
+        from startDate: Date,
+        to endDate: Date,
+        expectedIntervalMinutes: Int = 15
+    ) async throws -> [DataGap] {
+        let samples = try await healthKitManager.fetchSamples(
+            for: dataType,
+            from: startDate,
+            to: endDate
+        )
+
+        guard !samples.isEmpty else {
+            return [DataGap(
+                dataType: dataType,
+                timeWindow: TimeWindow(start: startDate, end: endDate),
+                expectedRecordCount: 0,
+                actualRecordCount: 0
+            )]
+        }
+
+        let sortedSamples = samples.sorted { $0.startDate < $1.startDate }
+        var gaps: [DataGap] = []
+        let expectedInterval = TimeInterval(expectedIntervalMinutes * 60)
+
+        // Check gap at start
+        if let firstSample = sortedSamples.first,
+           firstSample.startDate.timeIntervalSince(startDate) > expectedInterval * 2 {
+            gaps.append(DataGap(
+                dataType: dataType,
+                timeWindow: TimeWindow(start: startDate, end: firstSample.startDate),
+                expectedRecordCount: Int(firstSample.startDate.timeIntervalSince(startDate) / expectedInterval),
+                actualRecordCount: 0
+            ))
+        }
+
+        // Check gaps between samples
+        for i in 0..<(sortedSamples.count - 1) {
+            let current = sortedSamples[i]
+            let next = sortedSamples[i + 1]
+            let gap = next.startDate.timeIntervalSince(current.endDate)
+
+            if gap > expectedInterval * 2 {
+                gaps.append(DataGap(
+                    dataType: dataType,
+                    timeWindow: TimeWindow(start: current.endDate, end: next.startDate),
+                    expectedRecordCount: Int(gap / expectedInterval),
+                    actualRecordCount: 0
+                ))
+            }
+        }
+
+        // Check gap at end
+        if let lastSample = sortedSamples.last,
+           endDate.timeIntervalSince(lastSample.endDate) > expectedInterval * 2 {
+            gaps.append(DataGap(
+                dataType: dataType,
+                timeWindow: TimeWindow(start: lastSample.endDate, end: endDate),
+                expectedRecordCount: Int(endDate.timeIntervalSince(lastSample.endDate) / expectedInterval),
+                actualRecordCount: 0
+            ))
+        }
+
+        return gaps
+    }
+
+    // MARK: - Aggregated Data
+
+    func fetchDailySummary(for date: Date) async throws -> DailySummary {
+        let calendar = Calendar.current
+        let startOfDay = calendar.startOfDay(for: date)
+        let endOfDay = calendar.date(byAdding: .day, value: 1, to: startOfDay)!
+
+        var summary = DailySummary(date: date)
+
+        for dataType in HealthDataType.allCases {
+            do {
+                let samples = try await healthKitManager.fetchSamples(
+                    for: dataType,
+                    from: startOfDay,
+                    to: endOfDay
+                )
+
+                let value = aggregateValue(samples: samples, dataType: dataType)
+                summary.values[dataType] = value
+
+                // Check for conflicts
+                let windowData = try await fetchData(
+                    for: dataType,
+                    from: startOfDay,
+                    to: endOfDay
+                )
+                let conflictCount = windowData.filter { $0.hasConflict }.count
+                summary.conflictCounts[dataType] = conflictCount
+            } catch {
+                print("Failed to fetch \(dataType) for summary: \(error)")
+            }
+        }
+
+        return summary
+    }
+
+    private func aggregateValue(samples: [HKSample], dataType: HealthDataType) -> Double {
+        switch dataType {
+        case .steps, .floorsClimbed, .activeEnergy, .distance:
+            return samples.compactMap { sample -> Double? in
+                guard let quantitySample = sample as? HKQuantitySample else { return nil }
+                return quantitySample.quantity.doubleValue(for: dataType.hkUnit)
+            }.reduce(0, +)
+
+        case .heartRate, .restingHeartRate, .respiratoryRate, .heartRateVariability,
+             .bloodOxygen, .bloodPressureSystolic, .bloodPressureDiastolic:
+            let values = samples.compactMap { sample -> Double? in
+                guard let quantitySample = sample as? HKQuantitySample else { return nil }
+                return quantitySample.quantity.doubleValue(for: dataType.hkUnit)
+            }
+            return values.isEmpty ? 0 : values.reduce(0, +) / Double(values.count)
+
+        case .sleep:
+            return samples.reduce(0) { acc, sample in
+                acc + sample.endDate.timeIntervalSince(sample.startDate) / 3600
+            }
+        }
+    }
+}
+
+// MARK: - Supporting Types
+
+struct TimeWindowData: Identifiable {
+    let id = UUID()
+    let timeWindow: TimeWindow
+    let dataType: HealthDataType
+    let readings: [SourceReading]
+    let hasConflict: Bool
+
+    var primaryReading: SourceReading? {
+        readings.max { $0.sourceCategory.priority < $1.sourceCategory.priority }
+    }
+
+    var conflictSeverity: ConflictSeverity? {
+        guard hasConflict, readings.count >= 2 else { return nil }
+
+        let values = readings.map { $0.value }.filter { $0 > 0 }
+        guard let min = values.min(), let max = values.max(), min > 0 else { return nil }
+
+        let percentDiff = (max - min) / min * 100
+
+        if percentDiff < 5 { return .minor }
+        if percentDiff < 20 { return .moderate }
+        if percentDiff < 50 { return .significant }
+        return .major
+    }
+}
+
+struct ConflictThreshold {
+    let percentageThreshold: Double
+    let absoluteThreshold: Double
+}
+
+struct DataGap: Identifiable {
+    let id = UUID()
+    let dataType: HealthDataType
+    let timeWindow: TimeWindow
+    let expectedRecordCount: Int
+    let actualRecordCount: Int
+
+    var severity: GapSeverity {
+        let duration = timeWindow.duration
+        if duration < 3600 { return .minor } // < 1 hour
+        if duration < 4 * 3600 { return .moderate } // < 4 hours
+        if duration < 12 * 3600 { return .significant } // < 12 hours
+        return .major
+    }
+
+    enum GapSeverity {
+        case minor, moderate, significant, major
+    }
+}
+
+struct DailySummary {
+    let date: Date
+    var values: [HealthDataType: Double] = [:]
+    var conflictCounts: [HealthDataType: Int] = [:]
+    var lastUpdated = Date()
+
+    var totalConflicts: Int {
+        conflictCounts.values.reduce(0, +)
+    }
+
+    func formattedValue(for dataType: HealthDataType) -> String {
+        guard let value = values[dataType] else { return "–" }
+
+        switch dataType {
+        case .steps, .floorsClimbed:
+            return String(format: "%.0f", value)
+        case .distance:
+            return String(format: "%.2f km", value)
+        case .heartRate, .restingHeartRate, .respiratoryRate:
+            return String(format: "%.0f %@", value, dataType.unit)
+        case .bloodPressureSystolic, .bloodPressureDiastolic:
+            return String(format: "%.0f mmHg", value)
+        case .bloodOxygen:
+            return String(format: "%.0f%%", value * 100)
+        case .activeEnergy:
+            return String(format: "%.0f kcal", value)
+        case .sleep:
+            let hours = Int(value)
+            let minutes = Int((value - Double(hours)) * 60)
+            return "\(hours)h \(minutes)min"
+        case .heartRateVariability:
+            return String(format: "%.0f ms", value)
+        }
+    }
+}

HealthBridge/Services/DataWriter.swift

@@ -0,0 +1,395 @@
+import Foundation
+import HealthKit
+import Combine
+
+// MARK: - Data Writer
+@MainActor
+class DataWriter: ObservableObject {
+    static let shared = DataWriter()
+
+    private let healthKitManager = HealthKitManager.shared
+    private let healthStore = HKHealthStore()
+
+    @Published var isWriting = false
+    @Published var writeProgress: Double = 0
+    @Published var lastWriteDate: Date?
+    @Published var writtenRecords: [WrittenRecord] = []
+    @Published var failedWrites: [FailedWrite] = []
+
+    private let processedRecordsKey = "healthbridge.processed.records"
+
+    private init() {
+        loadProcessedRecords()
+    }
+
+    // MARK: - Write Single Record
+
+    func writeRecord(_ mergedRecord: MergedRecord) async throws -> WrittenRecord {
+        isWriting = true
+        defer { isWriting = false }
+
+        // Check if already written
+        if isAlreadyWritten(mergedRecord) {
+            throw DataWriterError.duplicateRecord
+        }
+
+        let metadata = createMetadata(from: mergedRecord)
+
+        switch mergedRecord.dataType {
+        case .bloodPressureSystolic, .bloodPressureDiastolic:
+            // Blood pressure needs special handling
+            guard let diastolic = mergedRecord.secondaryValue else {
+                throw DataWriterError.missingSecondaryValue
+            }
+            try await writeBloodPressure(
+                systolic: mergedRecord.value,
+                diastolic: diastolic,
+                date: mergedRecord.timeWindow.start,
+                metadata: metadata
+            )
+
+        default:
+            try await writeSample(
+                dataType: mergedRecord.dataType,
+                value: mergedRecord.value,
+                date: mergedRecord.timeWindow.start,
+                metadata: metadata
+            )
+        }
+
+        let writtenRecord = WrittenRecord(
+            id: UUID(),
+            mergedRecordId: mergedRecord.id,
+            dataType: mergedRecord.dataType,
+            value: mergedRecord.value,
+            secondaryValue: mergedRecord.secondaryValue,
+            writtenAt: Date(),
+            timeWindow: mergedRecord.timeWindow
+        )
+
+        writtenRecords.append(writtenRecord)
+        markAsProcessed(mergedRecord)
+        lastWriteDate = Date()
+
+        return writtenRecord
+    }
+
+    // MARK: - Write Batch
+
+    func writeBatch(_ mergedRecords: [MergedRecord]) async -> BatchWriteResult {
+        isWriting = true
+        defer { isWriting = false }
+
+        var successful: [WrittenRecord] = []
+        var failed: [FailedWrite] = []
+
+        for (index, record) in mergedRecords.enumerated() {
+            writeProgress = Double(index) / Double(mergedRecords.count)
+
+            do {
+                let writtenRecord = try await writeRecord(record)
+                successful.append(writtenRecord)
+            } catch {
+                let failedWrite = FailedWrite(
+                    mergedRecord: record,
+                    error: error,
+                    attemptedAt: Date()
+                )
+                failed.append(failedWrite)
+                failedWrites.append(failedWrite)
+            }
+        }
+
+        writeProgress = 1.0
+
+        return BatchWriteResult(
+            successful: successful,
+            failed: failed,
+            completedAt: Date()
+        )
+    }
+
+    // MARK: - Private Write Methods
+
+    private func writeSample(
+        dataType: HealthDataType,
+        value: Double,
+        date: Date,
+        metadata: [String: Any]
+    ) async throws {
+        guard let quantityType = dataType.hkQuantityType else {
+            throw DataWriterError.unsupportedDataType
+        }
+
+        let quantity = HKQuantity(unit: dataType.hkUnit, doubleValue: value)
+        let sample = HKQuantitySample(
+            type: quantityType,
+            quantity: quantity,
+            start: date,
+            end: date,
+            metadata: metadata
+        )
+
+        try await healthStore.save(sample)
+    }
+
+    private func writeBloodPressure(
+        systolic: Double,
+        diastolic: Double,
+        date: Date,
+        metadata: [String: Any]
+    ) async throws {
+        // Validate blood pressure values
+        let validation = BloodPressureHandler.shared.validate(
+            systolic: systolic,
+            diastolic: diastolic
+        )
+
+        if !validation.isValid {
+            throw DataWriterError.invalidValue(validation.issues.joined(separator: ", "))
+        }
+
+        guard let systolicType = HKQuantityType.quantityType(forIdentifier: .bloodPressureSystolic),
+              let diastolicType = HKQuantityType.quantityType(forIdentifier: .bloodPressureDiastolic),
+              let correlationType = HKCorrelationType.correlationType(forIdentifier: .bloodPressure) else {
+            throw DataWriterError.unsupportedDataType
+        }
+
+        let systolicQuantity = HKQuantity(unit: .millimeterOfMercury(), doubleValue: systolic)
+        let diastolicQuantity = HKQuantity(unit: .millimeterOfMercury(), doubleValue: diastolic)
+
+        let systolicSample = HKQuantitySample(
+            type: systolicType,
+            quantity: systolicQuantity,
+            start: date,
+            end: date,
+            metadata: metadata
+        )
+
+        let diastolicSample = HKQuantitySample(
+            type: diastolicType,
+            quantity: diastolicQuantity,
+            start: date,
+            end: date,
+            metadata: metadata
+        )
+
+        let correlation = HKCorrelation(
+            type: correlationType,
+            start: date,
+            end: date,
+            objects: [systolicSample, diastolicSample],
+            metadata: metadata
+        )
+
+        try await healthStore.save(correlation)
+    }
+
+    // MARK: - Metadata
+
+    private func createMetadata(from record: MergedRecord) -> [String: Any] {
+        var metadata: [String: Any] = [
+            HKMetadataKeyWasUserEntered: false,
+            "HealthBridgeSource": HealthBridgeConstants.bundleIdentifier,
+            "OriginalSourceId": record.originalSourceId,
+            "MergeStrategy": record.strategy.rawValue,
+            "MergedRecordId": record.id.uuidString,
+            "MergedAt": ISO8601DateFormatter().string(from: record.createdAt)
+        ]
+
+        for (key, value) in record.metadata {
+            metadata["HB_\(key)"] = value
+        }
+
+        return metadata
+    }
+
+    // MARK: - Duplicate Prevention
+
+    private var processedRecordIds: Set<String> = []
+
+    private func loadProcessedRecords() {
+        if let data = UserDefaults.standard.data(forKey: processedRecordsKey),
+           let ids = try? JSONDecoder().decode(Set<String>.self, from: data) {
+            processedRecordIds = ids
+        }
+    }
+
+    private func saveProcessedRecords() {
+        if let data = try? JSONEncoder().encode(processedRecordIds) {
+            UserDefaults.standard.set(data, forKey: processedRecordsKey)
+        }
+    }
+
+    private func isAlreadyWritten(_ record: MergedRecord) -> Bool {
+        let identifier = createRecordIdentifier(record)
+        return processedRecordIds.contains(identifier)
+    }
+
+    private func markAsProcessed(_ record: MergedRecord) {
+        let identifier = createRecordIdentifier(record)
+        processedRecordIds.insert(identifier)
+        saveProcessedRecords()
+
+        // Cleanup old records (keep last 7 days)
+        cleanupOldRecords()
+    }
+
+    private func createRecordIdentifier(_ record: MergedRecord) -> String {
+        let components = [
+            record.dataType.rawValue,
+            String(record.timeWindow.start.timeIntervalSince1970),
+            String(record.value)
+        ]
+        return components.joined(separator: "-")
+    }
+
+    private func cleanupOldRecords() {
+        // Keep only identifiers that contain recent timestamps
+        let sevenDaysAgo = Date().addingTimeInterval(-7 * 24 * 60 * 60)
+        let cutoffTimestamp = sevenDaysAgo.timeIntervalSince1970
+
+        processedRecordIds = processedRecordIds.filter { identifier in
+            guard let parts = identifier.split(separator: "-").dropFirst().first,
+                  let timestamp = Double(parts) else {
+                return false
+            }
+            return timestamp > cutoffTimestamp
+        }
+
+        saveProcessedRecords()
+    }
+
+    // MARK: - Delete Records
+
+    func deleteHealthBridgeRecords(
+        for dataType: HealthDataType,
+        from startDate: Date,
+        to endDate: Date
+    ) async throws -> Int {
+        guard let sampleType = dataType.hkQuantityType else {
+            throw DataWriterError.unsupportedDataType
+        }
+
+        let predicate = HKQuery.predicateForSamples(
+            withStart: startDate,
+            end: endDate,
+            options: .strictStartDate
+        )
+
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKSampleQuery(
+                sampleType: sampleType,
+                predicate: predicate,
+                limit: HKObjectQueryNoLimit,
+                sortDescriptors: nil
+            ) { [weak self] _, samplesOrNil, errorOrNil in
+                guard let self = self else {
+                    continuation.resume(throwing: DataWriterError.unknownError)
+                    return
+                }
+
+                if let error = errorOrNil {
+                    continuation.resume(throwing: error)
+                    return
+                }
+
+                guard let samples = samplesOrNil else {
+                    continuation.resume(returning: 0)
+                    return
+                }
+
+                // Filter to only HealthBridge records
+                let healthBridgeSamples = samples.filter { sample in
+                    if let metadata = sample.metadata,
+                       let source = metadata["HealthBridgeSource"] as? String {
+                        return source == HealthBridgeConstants.bundleIdentifier
+                    }
+                    return false
+                }
+
+                guard !healthBridgeSamples.isEmpty else {
+                    continuation.resume(returning: 0)
+                    return
+                }
+
+                Task {
+                    do {
+                        try await self.healthStore.delete(healthBridgeSamples)
+                        continuation.resume(returning: healthBridgeSamples.count)
+                    } catch {
+                        continuation.resume(throwing: error)
+                    }
+                }
+            }
+
+            healthStore.execute(query)
+        }
+    }
+}
+
+// MARK: - Supporting Types
+
+struct WrittenRecord: Identifiable, Codable {
+    let id: UUID
+    let mergedRecordId: UUID
+    let dataType: HealthDataType
+    let value: Double
+    let secondaryValue: Double?
+    let writtenAt: Date
+    let timeWindow: TimeWindow
+}
+
+struct FailedWrite: Identifiable {
+    let id = UUID()
+    let mergedRecord: MergedRecord
+    let error: Error
+    let attemptedAt: Date
+
+    var errorMessage: String {
+        error.localizedDescription
+    }
+}
+
+struct BatchWriteResult {
+    let successful: [WrittenRecord]
+    let failed: [FailedWrite]
+    let completedAt: Date
+
+    var successCount: Int { successful.count }
+    var failureCount: Int { failed.count }
+    var totalCount: Int { successCount + failureCount }
+
+    var successRate: Double {
+        guard totalCount > 0 else { return 1.0 }
+        return Double(successCount) / Double(totalCount)
+    }
+}
+
+// MARK: - Errors
+
+enum DataWriterError: LocalizedError {
+    case unsupportedDataType
+    case duplicateRecord
+    case missingSecondaryValue
+    case invalidValue(String)
+    case writeFailed(String)
+    case unknownError
+
+    var errorDescription: String? {
+        switch self {
+        case .unsupportedDataType:
+            return "Dieser Datentyp wird nicht unterstützt"
+        case .duplicateRecord:
+            return "Dieser Datensatz wurde bereits geschrieben"
+        case .missingSecondaryValue:
+            return "Fehlender sekundärer Wert (z.B. diastolischer Blutdruck)"
+        case .invalidValue(let message):
+            return "Ungültiger Wert: \(message)"
+        case .writeFailed(let message):
+            return "Schreiben fehlgeschlagen: \(message)"
+        case .unknownError:
+            return "Unbekannter Fehler"
+        }
+    }
+}

HealthBridge/Services/HealthKitManager.swift

@@ -0,0 +1,391 @@
+import Foundation
+import HealthKit
+import Combine
+
+// MARK: - HealthKit Manager
+@MainActor
+class HealthKitManager: ObservableObject {
+    static let shared = HealthKitManager()
+
+    private let healthStore = HKHealthStore()
+
+    @Published var isAuthorized = false
+    @Published var authorizationStatus: [HealthDataType: HKAuthorizationStatus] = [:]
+    @Published var discoveredSources: [HealthSource] = []
+    @Published var sourceHealthStatus: [String: SourceHealthStatus] = [:]
+    @Published var lastError: Error?
+
+    private init() {}
+
+    // MARK: - Authorization
+
+    var allQuantityTypes: Set<HKQuantityType> {
+        var types = Set<HKQuantityType>()
+        for dataType in HealthDataType.allCases {
+            if let quantityType = dataType.hkQuantityType {
+                types.insert(quantityType)
+            }
+        }
+        return types
+    }
+
+    var allCategoryTypes: Set<HKCategoryType> {
+        var types = Set<HKCategoryType>()
+        for dataType in HealthDataType.allCases {
+            if let categoryType = dataType.hkCategoryType {
+                types.insert(categoryType)
+            }
+        }
+        return types
+    }
+
+    var allSampleTypes: Set<HKSampleType> {
+        var types = Set<HKSampleType>()
+        allQuantityTypes.forEach { types.insert($0) }
+        allCategoryTypes.forEach { types.insert($0) }
+        return types
+    }
+
+    func requestAuthorization() async throws {
+        guard HKHealthStore.isHealthDataAvailable() else {
+            throw HealthKitError.healthDataNotAvailable
+        }
+
+        let typesToRead = allSampleTypes
+        let typesToWrite = allQuantityTypes
+
+        try await healthStore.requestAuthorization(toShare: typesToWrite, read: typesToRead)
+        isAuthorized = true
+
+        await updateAuthorizationStatus()
+        await discoverSources()
+    }
+
+    func updateAuthorizationStatus() async {
+        for dataType in HealthDataType.allCases {
+            if let quantityType = dataType.hkQuantityType {
+                let status = healthStore.authorizationStatus(for: quantityType)
+                authorizationStatus[dataType] = status
+            } else if let categoryType = dataType.hkCategoryType {
+                let status = healthStore.authorizationStatus(for: categoryType)
+                authorizationStatus[dataType] = status
+            }
+        }
+    }
+
+    // MARK: - Source Discovery
+
+    func discoverSources() async {
+        var allSources: [String: HealthSource] = [:]
+
+        for dataType in HealthDataType.allCases {
+            guard let sampleType = dataType.hkQuantityType ?? dataType.hkCategoryType else {
+                continue
+            }
+
+            do {
+                let sources = try await fetchSources(for: sampleType)
+                for source in sources {
+                    if var existingSource = allSources[source.bundleIdentifier] {
+                        existingSource.supportedDataTypes.insert(dataType)
+                        allSources[source.bundleIdentifier] = existingSource
+                    } else {
+                        var newSource = source
+                        newSource.supportedDataTypes.insert(dataType)
+                        allSources[source.bundleIdentifier] = newSource
+                    }
+                }
+            } catch {
+                print("Failed to fetch sources for \(dataType): \(error)")
+            }
+        }
+
+        discoveredSources = Array(allSources.values).sorted { $0.category.priority > $1.category.priority }
+
+        // Update source health status
+        for source in discoveredSources {
+            await updateSourceHealth(source)
+        }
+    }
+
+    private func fetchSources(for sampleType: HKSampleType) async throws -> [HealthSource] {
+        let query = HKSourceQuery(sampleType: sampleType, samplePredicate: nil) { _, sourcesOrNil, errorOrNil in
+            // Handled via continuation
+        }
+
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKSourceQuery(sampleType: sampleType, samplePredicate: nil) { _, sourcesOrNil, errorOrNil in
+                if let error = errorOrNil {
+                    continuation.resume(throwing: error)
+                    return
+                }
+
+                guard let sources = sourcesOrNil else {
+                    continuation.resume(returning: [])
+                    return
+                }
+
+                let healthSources = sources.map { HealthSource.from(hkSource: $0) }
+                continuation.resume(returning: healthSources)
+            }
+
+            healthStore.execute(query)
+        }
+    }
+
+    private func updateSourceHealth(_ source: HealthSource) async {
+        var recordCount = 0
+        var lastActivity: Date?
+
+        for dataType in source.supportedDataTypes {
+            if let quantityType = dataType.hkQuantityType {
+                let predicate = HKQuery.predicateForObjects(from: HKSource(bundleIdentifier: source.bundleIdentifier, name: source.name) )
+                // Simplified: just get count
+                if let count = try? await fetchRecordCount(for: quantityType, source: source) {
+                    recordCount += count
+                }
+                if let date = try? await fetchLastActivityDate(for: quantityType, source: source) {
+                    if lastActivity == nil || date > lastActivity! {
+                        lastActivity = date
+                    }
+                }
+            }
+        }
+
+        let status = SourceHealthStatus(
+            id: source.id,
+            source: source,
+            lastSync: lastActivity,
+            recordCount: recordCount,
+            dataGaps: [], // TODO: Implement gap detection
+            overallQuality: recordCount > 0 ? .complete : .missing
+        )
+
+        sourceHealthStatus[source.id] = status
+    }
+
+    private func fetchRecordCount(for sampleType: HKSampleType, source: HealthSource) async throws -> Int {
+        let calendar = Calendar.current
+        let now = Date()
+        let startOfDay = calendar.startOfDay(for: now)
+
+        let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: now, options: .strictStartDate)
+
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKSampleQuery(
+                sampleType: sampleType,
+                predicate: predicate,
+                limit: HKObjectQueryNoLimit,
+                sortDescriptors: nil
+            ) { _, samplesOrNil, errorOrNil in
+                if let error = errorOrNil {
+                    continuation.resume(throwing: error)
+                    return
+                }
+
+                let samples = samplesOrNil ?? []
+                let matchingSamples = samples.filter { $0.sourceRevision.source.bundleIdentifier == source.bundleIdentifier }
+                continuation.resume(returning: matchingSamples.count)
+            }
+
+            self.healthStore.execute(query)
+        }
+    }
+
+    private func fetchLastActivityDate(for sampleType: HKSampleType, source: HealthSource) async throws -> Date? {
+        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: false)
+
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKSampleQuery(
+                sampleType: sampleType,
+                predicate: nil,
+                limit: 1,
+                sortDescriptors: [sortDescriptor]
+            ) { _, samplesOrNil, errorOrNil in
+                if let error = errorOrNil {
+                    continuation.resume(throwing: error)
+                    return
+                }
+
+                let matchingSample = samplesOrNil?.first { $0.sourceRevision.source.bundleIdentifier == source.bundleIdentifier }
+                continuation.resume(returning: matchingSample?.endDate)
+            }
+
+            self.healthStore.execute(query)
+        }
+    }
+
+    // MARK: - Source Classification
+
+    func classifySource(_ source: HKSource) -> SourceCategory {
+        let bundleId = source.bundleIdentifier.lowercased()
+
+        if bundleId.contains("healthbridge") {
+            return .healthBridge
+        } else if bundleId.contains("apple.health") && !bundleId.contains("watch") {
+            return .iPhone
+        } else if bundleId.contains("apple") && bundleId.contains("watch") {
+            return .watch
+        } else if bundleId.contains("huawei") {
+            return .thirdPartyWatch
+        } else if bundleId.contains("samsung") || bundleId.contains("galaxy") {
+            return .thirdPartyWatch
+        } else if bundleId.contains("fitbit") {
+            return .thirdPartyWatch
+        } else if bundleId.contains("garmin") {
+            return .thirdPartyWatch
+        } else if bundleId.contains("polar") {
+            return .thirdPartyWatch
+        } else if bundleId.contains("withings") {
+            return .thirdPartyWatch
+        } else {
+            return .thirdPartyApp
+        }
+    }
+
+    func getSourceCapabilities(_ source: HealthSource) -> Set<HealthDataType> {
+        return source.supportedDataTypes
+    }
+
+    // MARK: - Data Fetching (Basic)
+
+    func fetchSamples(
+        for dataType: HealthDataType,
+        from startDate: Date,
+        to endDate: Date
+    ) async throws -> [HKSample] {
+        guard let sampleType = dataType.hkQuantityType ?? dataType.hkCategoryType else {
+            throw HealthKitError.unsupportedDataType
+        }
+
+        let predicate = HKQuery.predicateForSamples(
+            withStart: startDate,
+            end: endDate,
+            options: .strictStartDate
+        )
+
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKSampleQuery(
+                sampleType: sampleType,
+                predicate: predicate,
+                limit: HKObjectQueryNoLimit,
+                sortDescriptors: [NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)]
+            ) { _, samplesOrNil, errorOrNil in
+                if let error = errorOrNil {
+                    continuation.resume(throwing: error)
+                    return
+                }
+                continuation.resume(returning: samplesOrNil ?? [])
+            }
+
+            self.healthStore.execute(query)
+        }
+    }
+
+    // MARK: - Data Writing
+
+    func writeSample(
+        dataType: HealthDataType,
+        value: Double,
+        secondaryValue: Double? = nil,
+        date: Date,
+        metadata: [String: Any]? = nil
+    ) async throws {
+        guard let quantityType = dataType.hkQuantityType else {
+            throw HealthKitError.unsupportedDataType
+        }
+
+        let quantity = HKQuantity(unit: dataType.hkUnit, doubleValue: value)
+        let sample = HKQuantitySample(
+            type: quantityType,
+            quantity: quantity,
+            start: date,
+            end: date,
+            metadata: metadata
+        )
+
+        try await healthStore.save(sample)
+    }
+
+    func writeBloodPressure(
+        systolic: Double,
+        diastolic: Double,
+        date: Date,
+        metadata: [String: Any]? = nil
+    ) async throws {
+        guard let systolicType = HKQuantityType.quantityType(forIdentifier: .bloodPressureSystolic),
+              let diastolicType = HKQuantityType.quantityType(forIdentifier: .bloodPressureDiastolic) else {
+            throw HealthKitError.unsupportedDataType
+        }
+
+        let systolicQuantity = HKQuantity(unit: .millimeterOfMercury(), doubleValue: systolic)
+        let diastolicQuantity = HKQuantity(unit: .millimeterOfMercury(), doubleValue: diastolic)
+
+        let systolicSample = HKQuantitySample(
+            type: systolicType,
+            quantity: systolicQuantity,
+            start: date,
+            end: date,
+            metadata: metadata
+        )
+
+        let diastolicSample = HKQuantitySample(
+            type: diastolicType,
+            quantity: diastolicQuantity,
+            start: date,
+            end: date,
+            metadata: metadata
+        )
+
+        // Create correlation for blood pressure
+        guard let correlationType = HKCorrelationType.correlationType(forIdentifier: .bloodPressure) else {
+            throw HealthKitError.unsupportedDataType
+        }
+
+        let correlation = HKCorrelation(
+            type: correlationType,
+            start: date,
+            end: date,
+            objects: [systolicSample, diastolicSample],
+            metadata: metadata
+        )
+
+        try await healthStore.save(correlation)
+    }
+}
+
+// MARK: - HealthKit Errors
+enum HealthKitError: LocalizedError {
+    case healthDataNotAvailable
+    case authorizationDenied
+    case unsupportedDataType
+    case noDataFound
+    case writeFailed(Error)
+    case queryFailed(Error)
+
+    var errorDescription: String? {
+        switch self {
+        case .healthDataNotAvailable:
+            return "Health-Daten sind auf diesem Gerät nicht verfügbar"
+        case .authorizationDenied:
+            return "Zugriff auf Health-Daten wurde verweigert"
+        case .unsupportedDataType:
+            return "Dieser Datentyp wird nicht unterstützt"
+        case .noDataFound:
+            return "Keine Daten gefunden"
+        case .writeFailed(let error):
+            return "Schreiben fehlgeschlagen: \(error.localizedDescription)"
+        case .queryFailed(let error):
+            return "Abfrage fehlgeschlagen: \(error.localizedDescription)"
+        }
+    }
+}
+
+// MARK: - HKSource Extension
+extension HKSource {
+    convenience init(bundleIdentifier: String, name: String) {
+        // Note: This is a workaround since HKSource doesn't have a public initializer
+        // In production, sources come from HealthKit queries
+        fatalError("HKSource cannot be initialized directly - use source from HKSample")
+    }
+}

HealthBridge/Services/MergeEngine.swift

@@ -0,0 +1,287 @@
+import Foundation
+import Combine
+
+// MARK: - Merge Engine
+@MainActor
+class MergeEngine: ObservableObject {
+    static let shared = MergeEngine()
+
+    private let ruleEngine = RuleEngine.shared
+    private let dataReader = DataReader.shared
+
+    @Published var pendingMerges: [MergeOperation] = []
+    @Published var completedMerges: [MergeOperation] = []
+    @Published var isMerging = false
+    @Published var mergeProgress: Double = 0
+
+    private init() {}
+
+    // MARK: - Analyze Window
+
+    func analyze(windowData: TimeWindowData) -> WindowAnalysis {
+        let readings = windowData.readings
+        let dataType = windowData.dataType
+
+        // No analysis needed for single reading
+        if readings.count <= 1 {
+            return WindowAnalysis(
+                windowData: windowData,
+                hasConflict: false,
+                conflictSeverity: nil,
+                recommendedReading: readings.first,
+                alternativeReadings: [],
+                confidence: .high,
+                analysisNotes: readings.isEmpty ? "Keine Daten" : "Einzelne Quelle"
+            )
+        }
+
+        // Apply rule to get recommendation
+        let result = ruleEngine.applyRule(to: readings, dataType: dataType)
+
+        // Calculate conflict severity
+        let values = readings.map { $0.value }.filter { $0 > 0 }
+        var severity: ConflictSeverity? = nil
+
+        if values.count >= 2, let min = values.min(), let max = values.max(), min > 0 {
+            let percentDiff = (max - min) / min * 100
+            if percentDiff >= 5 {
+                if percentDiff < 10 { severity = .minor }
+                else if percentDiff < 25 { severity = .moderate }
+                else if percentDiff < 50 { severity = .significant }
+                else { severity = .major }
+            }
+        }
+
+        let alternativeReadings = readings.filter { $0.id != result.selectedReading?.id }
+
+        return WindowAnalysis(
+            windowData: windowData,
+            hasConflict: windowData.hasConflict,
+            conflictSeverity: severity,
+            recommendedReading: result.selectedReading,
+            alternativeReadings: alternativeReadings,
+            confidence: result.confidence,
+            analysisNotes: result.reason
+        )
+    }
+
+    // MARK: - Resolve Conflict
+
+    func resolveConflict(_ conflict: Conflict, using result: RuleApplicationResult) -> ConflictResolution? {
+        guard let selectedReading = result.selectedReading else {
+            return nil
+        }
+
+        return ConflictResolution(
+            resolvedValue: selectedReading.value,
+            secondaryResolvedValue: selectedReading.secondaryValue,
+            winningSourceId: selectedReading.sourceId,
+            strategy: result.strategy,
+            isManual: result.strategy == .manual
+        )
+    }
+
+    func resolveConflictManually(
+        _ conflict: Conflict,
+        selectedReadingId: UUID
+    ) -> ConflictResolution? {
+        guard let selectedReading = conflict.readings.first(where: { $0.id == selectedReadingId }) else {
+            return nil
+        }
+
+        return ConflictResolution(
+            resolvedValue: selectedReading.value,
+            secondaryResolvedValue: selectedReading.secondaryValue,
+            winningSourceId: selectedReading.sourceId,
+            strategy: .manual,
+            isManual: true
+        )
+    }
+
+    // MARK: - Create Merged Record
+
+    func createMergedRecord(from conflict: Conflict, resolution: ConflictResolution) -> MergedRecord {
+        return MergedRecord(
+            id: UUID(),
+            dataType: conflict.dataType,
+            timeWindow: conflict.timeWindow,
+            value: resolution.resolvedValue,
+            secondaryValue: resolution.secondaryResolvedValue,
+            originalSourceId: resolution.winningSourceId,
+            strategy: resolution.strategy,
+            createdAt: Date(),
+            metadata: [
+                "conflictId": conflict.id.uuidString,
+                "originalSourceCount": String(conflict.readings.count),
+                "isManualResolution": String(resolution.isManual)
+            ]
+        )
+    }
+
+    // MARK: - Batch Processing
+
+    func processConflicts(_ conflicts: [Conflict]) async -> [MergeOperation] {
+        isMerging = true
+        defer { isMerging = false }
+
+        var operations: [MergeOperation] = []
+
+        for (index, conflict) in conflicts.enumerated() {
+            mergeProgress = Double(index) / Double(conflicts.count)
+
+            let result = ruleEngine.applyRule(to: conflict.readings, dataType: conflict.dataType)
+
+            if result.confidence == .requiresManual ||
+               ruleEngine.shouldRequestManualReview(readings: conflict.readings, dataType: conflict.dataType) {
+                // Add to pending for manual review
+                let operation = MergeOperation(
+                    conflict: conflict,
+                    status: .pendingManualReview,
+                    result: result
+                )
+                pendingMerges.append(operation)
+                operations.append(operation)
+            } else if let resolution = resolveConflict(conflict, using: result) {
+                // Auto-resolve
+                let mergedRecord = createMergedRecord(from: conflict, resolution: resolution)
+                let operation = MergeOperation(
+                    conflict: conflict,
+                    status: .resolved,
+                    result: result,
+                    resolution: resolution,
+                    mergedRecord: mergedRecord
+                )
+                completedMerges.append(operation)
+                operations.append(operation)
+            }
+        }
+
+        mergeProgress = 1.0
+        return operations
+    }
+
+    // MARK: - Daily Merge
+
+    func performDailyMerge(for date: Date) async throws -> DailyMergeReport {
+        let calendar = Calendar.current
+        let startOfDay = calendar.startOfDay(for: date)
+        let endOfDay = calendar.date(byAdding: .day, value: 1, to: startOfDay)!
+
+        var report = DailyMergeReport(date: date)
+
+        for dataType in HealthDataType.allCases {
+            do {
+                let windowData = try await dataReader.fetchData(
+                    for: dataType,
+                    from: startOfDay,
+                    to: endOfDay
+                )
+
+                let conflictWindows = windowData.filter { $0.hasConflict }
+                report.totalConflicts += conflictWindows.count
+
+                for window in conflictWindows {
+                    let analysis = analyze(windowData: window)
+
+                    if analysis.confidence == .requiresManual {
+                        report.pendingManualReview += 1
+                    } else {
+                        report.autoResolved += 1
+                    }
+
+                    report.analysesByType[dataType, default: []].append(analysis)
+                }
+            } catch {
+                report.errors.append("Fehler bei \(dataType.displayName): \(error.localizedDescription)")
+            }
+        }
+
+        return report
+    }
+}
+
+// MARK: - Supporting Types
+
+struct WindowAnalysis {
+    let windowData: TimeWindowData
+    let hasConflict: Bool
+    let conflictSeverity: ConflictSeverity?
+    let recommendedReading: SourceReading?
+    let alternativeReadings: [SourceReading]
+    let confidence: RuleConfidence
+    let analysisNotes: String
+
+    var recommendedValue: Double? {
+        recommendedReading?.value
+    }
+
+    var valueDifference: Double? {
+        guard let recommended = recommendedReading?.value,
+              let alternative = alternativeReadings.first?.value else {
+            return nil
+        }
+        return abs(recommended - alternative)
+    }
+}
+
+struct MergeOperation: Identifiable {
+    let id = UUID()
+    let conflict: Conflict
+    var status: MergeStatus
+    let result: RuleApplicationResult
+    var resolution: ConflictResolution?
+    var mergedRecord: MergedRecord?
+    let createdAt = Date()
+    var processedAt: Date?
+
+    enum MergeStatus {
+        case pending
+        case pendingManualReview
+        case resolved
+        case written
+        case failed
+    }
+}
+
+struct MergedRecord: Identifiable, Codable {
+    let id: UUID
+    let dataType: HealthDataType
+    let timeWindow: TimeWindow
+    let value: Double
+    let secondaryValue: Double?
+    let originalSourceId: String
+    let strategy: MergeStrategy
+    let createdAt: Date
+    var writtenAt: Date?
+    var healthKitRecordId: String?
+    var metadata: [String: String]
+
+    var formattedValue: String {
+        if value == floor(value) {
+            return String(format: "%.0f", value)
+        }
+        return String(format: "%.1f", value)
+    }
+}
+
+struct DailyMergeReport {
+    let date: Date
+    var totalConflicts = 0
+    var autoResolved = 0
+    var pendingManualReview = 0
+    var analysesByType: [HealthDataType: [WindowAnalysis]] = [:]
+    var errors: [String] = []
+    let generatedAt = Date()
+
+    var successRate: Double {
+        guard totalConflicts > 0 else { return 1.0 }
+        return Double(autoResolved) / Double(totalConflicts)
+    }
+
+    var summary: String {
+        if totalConflicts == 0 {
+            return "Keine Konflikte gefunden"
+        }
+        return "\(autoResolved)/\(totalConflicts) automatisch gelöst, \(pendingManualReview) zur Prüfung"
+    }
+}

HealthBridge/Services/RuleEngine.swift

@@ -0,0 +1,571 @@
+import Foundation
+import Combine
+
+// MARK: - Rule Engine
+@MainActor
+class RuleEngine: ObservableObject {
+    static let shared = RuleEngine()
+
+    @Published var rules: [HealthDataType: MergeRule] = [:]
+    @Published var isLoaded = false
+
+    private let storage = RuleStorageManager()
+    private let sourceManager = SourceManager.shared
+
+    private init() {
+        loadRules()
+    }
+
+    // MARK: - Rule Loading
+
+    func loadRules() {
+        let savedRules = storage.loadRules()
+
+        if savedRules.isEmpty {
+            // Initialize with defaults
+            for dataType in HealthDataType.allCases {
+                rules[dataType] = MergeRule.defaultRule(for: dataType)
+            }
+            saveRules()
+        } else {
+            rules = savedRules
+        }
+
+        isLoaded = true
+    }
+
+    func saveRules() {
+        storage.saveRules(rules)
+    }
+
+    // MARK: - Rule Access
+
+    func getRule(for dataType: HealthDataType) -> MergeRule {
+        return rules[dataType] ?? MergeRule.defaultRule(for: dataType)
+    }
+
+    func setRule(_ rule: MergeRule, for dataType: HealthDataType) {
+        rules[dataType] = rule
+        saveRules()
+    }
+
+    func resetToDefault(for dataType: HealthDataType) {
+        rules[dataType] = MergeRule.defaultRule(for: dataType)
+        saveRules()
+    }
+
+    func resetAllToDefaults() {
+        for dataType in HealthDataType.allCases {
+            rules[dataType] = MergeRule.defaultRule(for: dataType)
+        }
+        saveRules()
+    }
+
+    // MARK: - Rule Application
+
+    func applyRule(
+        to readings: [SourceReading],
+        dataType: HealthDataType
+    ) -> RuleApplicationResult {
+        let rule = getRule(for: dataType)
+
+        // Filter out empty/zero readings for most strategies
+        let validReadings = readings.filter { $0.value > 0 || $0.quality == .complete }
+
+        guard !validReadings.isEmpty else {
+            return RuleApplicationResult(
+                selectedReading: nil,
+                strategy: rule.strategy,
+                confidence: .low,
+                reason: "Keine gültigen Werte vorhanden"
+            )
+        }
+
+        // If only one valid reading, no conflict
+        if validReadings.count == 1 {
+            return RuleApplicationResult(
+                selectedReading: validReadings[0],
+                strategy: rule.strategy,
+                confidence: .high,
+                reason: "Nur eine Quelle verfügbar"
+            )
+        }
+
+        // Apply strategy
+        switch rule.strategy {
+        case .exclusive:
+            return applyExclusiveStrategy(readings: validReadings, rule: rule)
+
+        case .priority:
+            return applyPriorityStrategy(readings: validReadings, rule: rule, dataType: dataType)
+
+        case .higherWins:
+            return applyHigherWinsStrategy(readings: validReadings, rule: rule)
+
+        case .lowerWins:
+            return applyLowerWinsStrategy(readings: validReadings, rule: rule)
+
+        case .average:
+            return applyAverageStrategy(readings: validReadings, rule: rule)
+
+        case .coverage:
+            return applyCoverageStrategy(readings: validReadings, rule: rule)
+
+        case .coverageThenHigher:
+            return applyCoverageThenHigherStrategy(readings: validReadings, rule: rule)
+
+        case .mostRecent:
+            return applyMostRecentStrategy(readings: validReadings, rule: rule)
+
+        case .manual:
+            return RuleApplicationResult(
+                selectedReading: nil,
+                strategy: .manual,
+                confidence: .requiresManual,
+                reason: "Manuelle Entscheidung erforderlich"
+            )
+        }
+    }
+
+    // MARK: - Strategy Implementations
+
+    private func applyExclusiveStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        // If primary source is specified, use it
+        if let primaryId = rule.primarySourceId,
+           let reading = readings.first(where: { $0.sourceId == primaryId }) {
+            return RuleApplicationResult(
+                selectedReading: reading,
+                strategy: .exclusive,
+                confidence: .high,
+                reason: "Exklusive Quelle: \(reading.sourceName)"
+            )
+        }
+
+        // Otherwise use highest priority source
+        let sorted = readings.sorted { $0.sourceCategory.priority > $1.sourceCategory.priority }
+        if let first = sorted.first {
+            return RuleApplicationResult(
+                selectedReading: first,
+                strategy: .exclusive,
+                confidence: .high,
+                reason: "Höchste Priorität: \(first.sourceName)"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .exclusive,
+            confidence: .low,
+            reason: "Keine geeignete Quelle gefunden"
+        )
+    }
+
+    private func applyPriorityStrategy(
+        readings: [SourceReading],
+        rule: MergeRule,
+        dataType: HealthDataType
+    ) -> RuleApplicationResult {
+        // Sort by user-defined priority, then by category priority
+        let sorted = readings.sorted { r1, r2 in
+            let p1 = rule.sourcePriorities[r1.sourceId] ?? r1.sourceCategory.priority
+            let p2 = rule.sourcePriorities[r2.sourceId] ?? r2.sourceCategory.priority
+            return p1 > p2
+        }
+
+        if let first = sorted.first {
+            return RuleApplicationResult(
+                selectedReading: first,
+                strategy: .priority,
+                confidence: .high,
+                reason: "Höchste Priorität: \(first.sourceName)"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .priority,
+            confidence: .low,
+            reason: "Keine Quelle mit Priorität gefunden"
+        )
+    }
+
+    private func applyHigherWinsStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        let sorted = readings.sorted { $0.value > $1.value }
+
+        if let highest = sorted.first {
+            // Check if there's a significant difference
+            let values = readings.map { $0.value }
+            let spread = (values.max() ?? 0) - (values.min() ?? 0)
+            let avgValue = values.reduce(0, +) / Double(values.count)
+            let spreadPercent = avgValue > 0 ? (spread / avgValue) * 100 : 0
+
+            let confidence: RuleConfidence = spreadPercent < 10 ? .high : .medium
+
+            return RuleApplicationResult(
+                selectedReading: highest,
+                strategy: .higherWins,
+                confidence: confidence,
+                reason: "Höchster Wert: \(highest.formattedValue) von \(highest.sourceName)"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .higherWins,
+            confidence: .low,
+            reason: "Keine Werte zum Vergleich"
+        )
+    }
+
+    private func applyLowerWinsStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        let sorted = readings.sorted { $0.value < $1.value }
+
+        if let lowest = sorted.first {
+            return RuleApplicationResult(
+                selectedReading: lowest,
+                strategy: .lowerWins,
+                confidence: .medium,
+                reason: "Niedrigster Wert: \(lowest.formattedValue) von \(lowest.sourceName)"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .lowerWins,
+            confidence: .low,
+            reason: "Keine Werte zum Vergleich"
+        )
+    }
+
+    private func applyAverageStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        let values = readings.map { $0.value }
+        let average = values.reduce(0, +) / Double(values.count)
+
+        // Create a synthetic reading for the average
+        let syntheticReading = SourceReading(
+            sourceId: HealthBridgeConstants.bundleIdentifier,
+            sourceName: "Durchschnitt",
+            sourceCategory: .healthBridge,
+            value: average,
+            timestamp: readings.first?.timestamp ?? Date(),
+            quality: .complete
+        )
+
+        return RuleApplicationResult(
+            selectedReading: syntheticReading,
+            strategy: .average,
+            confidence: .medium,
+            reason: "Durchschnitt aus \(readings.count) Quellen"
+        )
+    }
+
+    private func applyCoverageStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        // Prefer readings with complete quality
+        let completeReadings = readings.filter { $0.quality == .complete }
+
+        if completeReadings.count == 1 {
+            return RuleApplicationResult(
+                selectedReading: completeReadings[0],
+                strategy: .coverage,
+                confidence: .high,
+                reason: "Einzige Quelle mit vollständigen Daten: \(completeReadings[0].sourceName)"
+            )
+        }
+
+        // If multiple complete readings, fall back to priority
+        if !completeReadings.isEmpty {
+            let sorted = completeReadings.sorted { $0.sourceCategory.priority > $1.sourceCategory.priority }
+            if let first = sorted.first {
+                return RuleApplicationResult(
+                    selectedReading: first,
+                    strategy: .coverage,
+                    confidence: .medium,
+                    reason: "Mehrere Quellen verfügbar, gewählt: \(first.sourceName)"
+                )
+            }
+        }
+
+        // No complete readings, use any reading with highest priority
+        let sorted = readings.sorted { $0.sourceCategory.priority > $1.sourceCategory.priority }
+        if let first = sorted.first {
+            return RuleApplicationResult(
+                selectedReading: first,
+                strategy: .coverage,
+                confidence: .low,
+                reason: "Keine vollständigen Daten, gewählt: \(first.sourceName)"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .coverage,
+            confidence: .low,
+            reason: "Keine Quelle mit Daten gefunden"
+        )
+    }
+
+    private func applyCoverageThenHigherStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        // First check if one source has data and others don't (coverage)
+        let nonZeroReadings = readings.filter { $0.value > 0 }
+        let zeroReadings = readings.filter { $0.value == 0 }
+
+        // If only one source has data, it wins on coverage
+        if nonZeroReadings.count == 1 && !zeroReadings.isEmpty {
+            return RuleApplicationResult(
+                selectedReading: nonZeroReadings[0],
+                strategy: .coverageThenHigher,
+                confidence: .high,
+                reason: "Einzige Quelle mit Daten: \(nonZeroReadings[0].sourceName)"
+            )
+        }
+
+        // Multiple sources have data, use higher wins
+        if nonZeroReadings.count > 1 {
+            let sorted = nonZeroReadings.sorted { $0.value > $1.value }
+            if let highest = sorted.first {
+                return RuleApplicationResult(
+                    selectedReading: highest,
+                    strategy: .coverageThenHigher,
+                    confidence: .medium,
+                    reason: "Höherer Wert bei Konflikt: \(highest.formattedValue) von \(highest.sourceName)"
+                )
+            }
+        }
+
+        // Fallback
+        if let first = readings.first {
+            return RuleApplicationResult(
+                selectedReading: first,
+                strategy: .coverageThenHigher,
+                confidence: .low,
+                reason: "Fallback auf erste Quelle"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .coverageThenHigher,
+            confidence: .low,
+            reason: "Keine Daten verfügbar"
+        )
+    }
+
+    private func applyMostRecentStrategy(
+        readings: [SourceReading],
+        rule: MergeRule
+    ) -> RuleApplicationResult {
+        let sorted = readings.sorted { $0.timestamp > $1.timestamp }
+
+        if let mostRecent = sorted.first {
+            return RuleApplicationResult(
+                selectedReading: mostRecent,
+                strategy: .mostRecent,
+                confidence: .high,
+                reason: "Neuester Wert von \(mostRecent.sourceName)"
+            )
+        }
+
+        return RuleApplicationResult(
+            selectedReading: nil,
+            strategy: .mostRecent,
+            confidence: .low,
+            reason: "Keine Zeitstempel verfügbar"
+        )
+    }
+
+    // MARK: - Threshold Check
+
+    func shouldRequestManualReview(
+        readings: [SourceReading],
+        dataType: HealthDataType
+    ) -> Bool {
+        let rule = getRule(for: dataType)
+
+        guard let threshold = rule.thresholdForManualReview else {
+            return rule.strategy == .manual
+        }
+
+        let values = readings.map { $0.value }.filter { $0 > 0 }
+        guard values.count >= 2,
+              let min = values.min(),
+              let max = values.max(),
+              min > 0 else {
+            return false
+        }
+
+        let percentDiff = (max - min) / min * 100
+        return percentDiff > threshold
+    }
+}
+
+// MARK: - Rule Application Result
+struct RuleApplicationResult {
+    let selectedReading: SourceReading?
+    let strategy: MergeStrategy
+    let confidence: RuleConfidence
+    let reason: String
+
+    var resolvedValue: Double? {
+        selectedReading?.value
+    }
+
+    var winningSourceId: String? {
+        selectedReading?.sourceId
+    }
+}
+
+enum RuleConfidence: String, Codable {
+    case high = "high"
+    case medium = "medium"
+    case low = "low"
+    case requiresManual = "requires_manual"
+
+    var displayName: String {
+        switch self {
+        case .high: return "Hohe Sicherheit"
+        case .medium: return "Mittlere Sicherheit"
+        case .low: return "Geringe Sicherheit"
+        case .requiresManual: return "Manuelle Prüfung"
+        }
+    }
+
+    var icon: String {
+        switch self {
+        case .high: return "checkmark.seal.fill"
+        case .medium: return "checkmark.seal"
+        case .low: return "questionmark.circle"
+        case .requiresManual: return "hand.raised.fill"
+        }
+    }
+}
+
+// MARK: - Rule Storage Manager
+class RuleStorageManager {
+    private let userDefaults = UserDefaults.standard
+    private let rulesKey = "healthbridge.merge.rules"
+
+    func saveRules(_ rules: [HealthDataType: MergeRule]) {
+        do {
+            let data = try JSONEncoder().encode(rules)
+            userDefaults.set(data, forKey: rulesKey)
+        } catch {
+            print("Failed to save rules: \(error)")
+        }
+    }
+
+    func loadRules() -> [HealthDataType: MergeRule] {
+        guard let data = userDefaults.data(forKey: rulesKey) else {
+            return [:]
+        }
+
+        do {
+            return try JSONDecoder().decode([HealthDataType: MergeRule].self, from: data)
+        } catch {
+            print("Failed to load rules: \(error)")
+            return [:]
+        }
+    }
+}
+
+// MARK: - Blood Pressure Handler
+class BloodPressureHandler {
+    static let shared = BloodPressureHandler()
+
+    struct ValidationResult {
+        let isValid: Bool
+        let issues: [String]
+    }
+
+    func validate(systolic: Double, diastolic: Double) -> ValidationResult {
+        var issues: [String] = []
+
+        // Range validation
+        if systolic < 70 || systolic > 200 {
+            issues.append("Systolischer Wert ausserhalb des Normalbereichs (70-200 mmHg)")
+        }
+
+        if diastolic < 40 || diastolic > 130 {
+            issues.append("Diastolischer Wert ausserhalb des Normalbereichs (40-130 mmHg)")
+        }
+
+        // Plausibility check
+        if diastolic >= systolic {
+            issues.append("Diastolischer Wert muss kleiner als systolischer Wert sein")
+        }
+
+        if systolic - diastolic < 20 {
+            issues.append("Pulsdruck zu gering (< 20 mmHg)")
+        }
+
+        if systolic - diastolic > 100 {
+            issues.append("Pulsdruck zu hoch (> 100 mmHg)")
+        }
+
+        return ValidationResult(isValid: issues.isEmpty, issues: issues)
+    }
+
+    func classifyBloodPressure(systolic: Double, diastolic: Double) -> BloodPressureClassification {
+        if systolic < 120 && diastolic < 80 {
+            return .normal
+        } else if systolic < 130 && diastolic < 80 {
+            return .elevated
+        } else if systolic < 140 || diastolic < 90 {
+            return .hypertensionStage1
+        } else if systolic < 180 || diastolic < 120 {
+            return .hypertensionStage2
+        } else {
+            return .hypertensiveCrisis
+        }
+    }
+
+    enum BloodPressureClassification: String {
+        case normal = "Normal"
+        case elevated = "Erhöht"
+        case hypertensionStage1 = "Bluthochdruck Stufe 1"
+        case hypertensionStage2 = "Bluthochdruck Stufe 2"
+        case hypertensiveCrisis = "Hypertensive Krise"
+
+        var color: String {
+            switch self {
+            case .normal: return "green"
+            case .elevated: return "yellow"
+            case .hypertensionStage1: return "orange"
+            case .hypertensionStage2: return "red"
+            case .hypertensiveCrisis: return "purple"
+            }
+        }
+
+        var recommendation: String {
+            switch self {
+            case .normal:
+                return "Weiter so! Regelmässige Kontrolle empfohlen."
+            case .elevated:
+                return "Lebensstiländerungen empfohlen. Mehr Bewegung, weniger Salz."
+            case .hypertensionStage1:
+                return "Arztbesuch empfohlen. Möglicherweise Medikation erforderlich."
+            case .hypertensionStage2:
+                return "Zeitnaher Arztbesuch erforderlich. Medikation wahrscheinlich notwendig."
+            case .hypertensiveCrisis:
+                return "SOFORT medizinische Hilfe aufsuchen!"
+            }
+        }
+    }
+}

HealthBridge/Services/SourceManager.swift

@@ -0,0 +1,409 @@
+import Foundation
+import HealthKit
+import Combine
+
+// MARK: - Source Manager
+@MainActor
+class SourceManager: ObservableObject {
+    static let shared = SourceManager()
+
+    @Published var sources: [HealthSource] = []
+    @Published var sourceProfiles: [String: SourceProfile] = [:]
+    @Published var isDiscovering = false
+
+    private let healthKitManager = HealthKitManager.shared
+    private let storage = SourceStorageManager()
+
+    private init() {}
+
+    // MARK: - Source Discovery
+
+    func discoverSources() async {
+        isDiscovering = true
+        defer { isDiscovering = false }
+
+        await healthKitManager.discoverSources()
+        sources = healthKitManager.discoveredSources
+
+        // Load saved source profiles and merge with discovered sources
+        let savedProfiles = storage.loadSourceProfiles()
+        for source in sources {
+            if let savedProfile = savedProfiles[source.bundleIdentifier] {
+                sourceProfiles[source.bundleIdentifier] = savedProfile
+            } else {
+                sourceProfiles[source.bundleIdentifier] = SourceProfile(source: source)
+            }
+        }
+    }
+
+    // MARK: - Source Classification
+
+    func classifySource(_ bundleIdentifier: String) -> SourceCategory {
+        let lowercased = bundleIdentifier.lowercased()
+
+        // HealthBridge
+        if lowercased.contains("healthbridge") {
+            return .healthBridge
+        }
+
+        // Apple Devices
+        if lowercased.contains("com.apple") {
+            if lowercased.contains("watch") || lowercased.contains("nano") {
+                return .watch
+            }
+            if lowercased.contains("health") {
+                return .iPhone
+            }
+        }
+
+        // Known Watch Brands
+        let watchBrands = ["huawei", "samsung", "galaxy", "fitbit", "garmin", "polar",
+                          "withings", "amazfit", "xiaomi", "honor", "oppo", "suunto",
+                          "coros", "whoop", "oura"]
+        for brand in watchBrands {
+            if lowercased.contains(brand) {
+                return .thirdPartyWatch
+            }
+        }
+
+        // Known Health Apps
+        let healthApps = ["strava", "nike", "adidas", "runtastic", "runkeeper",
+                         "mapmyrun", "endomondo", "myfitnesspal", "flo", "clue"]
+        for app in healthApps {
+            if lowercased.contains(app) {
+                return .thirdPartyApp
+            }
+        }
+
+        return .unknown
+    }
+
+    // MARK: - Source Capabilities
+
+    func getSourceCapabilities(_ source: HealthSource) -> SourceCapabilities {
+        let category = source.category
+
+        switch category {
+        case .iPhone:
+            return SourceCapabilities(
+                canMeasureSteps: true,
+                canMeasureDistance: true,
+                canMeasureFloors: true,
+                canMeasureHeartRate: false,
+                canMeasureBloodPressure: false,
+                canMeasureBloodOxygen: false,
+                canMeasureSleep: false,
+                canMeasureWorkouts: true,
+                hasGPS: true,
+                hasBarometer: true,
+                hasAccelerometer: true
+            )
+
+        case .watch:
+            return SourceCapabilities(
+                canMeasureSteps: true,
+                canMeasureDistance: true,
+                canMeasureFloors: false,
+                canMeasureHeartRate: true,
+                canMeasureBloodPressure: false,
+                canMeasureBloodOxygen: true,
+                canMeasureSleep: true,
+                canMeasureWorkouts: true,
+                hasGPS: true,
+                hasBarometer: false,
+                hasAccelerometer: true
+            )
+
+        case .thirdPartyWatch:
+            // Check for specific features based on name
+            let name = source.name.lowercased()
+            let isHuaweiD2 = name.contains("huawei") && (name.contains("d2") || name.contains("watch d"))
+
+            return SourceCapabilities(
+                canMeasureSteps: true,
+                canMeasureDistance: true,
+                canMeasureFloors: false,
+                canMeasureHeartRate: true,
+                canMeasureBloodPressure: isHuaweiD2, // Huawei Watch D2 has BP sensor
+                canMeasureBloodOxygen: true,
+                canMeasureSleep: true,
+                canMeasureWorkouts: true,
+                hasGPS: true,
+                hasBarometer: false,
+                hasAccelerometer: true
+            )
+
+        case .thirdPartyApp:
+            return SourceCapabilities(
+                canMeasureSteps: true,
+                canMeasureDistance: true,
+                canMeasureFloors: false,
+                canMeasureHeartRate: false,
+                canMeasureBloodPressure: false,
+                canMeasureBloodOxygen: false,
+                canMeasureSleep: false,
+                canMeasureWorkouts: true,
+                hasGPS: true,
+                hasBarometer: false,
+                hasAccelerometer: false
+            )
+
+        case .healthBridge, .unknown:
+            return SourceCapabilities.empty
+        }
+    }
+
+    // MARK: - Source Health
+
+    func getSourceHealth(_ source: HealthSource) async -> SourceHealthReport {
+        var dataGaps: [HealthDataType: [TimeWindow]] = [:]
+        var lastActivityByType: [HealthDataType: Date] = [:]
+        var recordCountByType: [HealthDataType: Int] = [:]
+
+        let calendar = Calendar.current
+        let now = Date()
+        let yesterday = calendar.date(byAdding: .day, value: -1, to: now)!
+
+        for dataType in source.supportedDataTypes {
+            do {
+                let samples = try await healthKitManager.fetchSamples(
+                    for: dataType,
+                    from: yesterday,
+                    to: now
+                )
+
+                let matchingSamples = samples.filter {
+                    $0.sourceRevision.source.bundleIdentifier == source.bundleIdentifier
+                }
+
+                recordCountByType[dataType] = matchingSamples.count
+
+                if let lastSample = matchingSamples.last {
+                    lastActivityByType[dataType] = lastSample.endDate
+                }
+
+                // Detect gaps
+                let gaps = detectDataGaps(
+                    in: matchingSamples,
+                    from: yesterday,
+                    to: now,
+                    expectedInterval: 15 * 60 // 15 minutes
+                )
+                if !gaps.isEmpty {
+                    dataGaps[dataType] = gaps
+                }
+            } catch {
+                print("Error checking health for \(dataType): \(error)")
+            }
+        }
+
+        let overallQuality: DataQuality
+        if recordCountByType.values.reduce(0, +) == 0 {
+            overallQuality = .missing
+        } else if dataGaps.isEmpty {
+            overallQuality = .complete
+        } else {
+            overallQuality = .partial
+        }
+
+        return SourceHealthReport(
+            source: source,
+            lastActivityByType: lastActivityByType,
+            recordCountByType: recordCountByType,
+            dataGaps: dataGaps,
+            overallQuality: overallQuality,
+            checkedAt: Date()
+        )
+    }
+
+    private func detectDataGaps(
+        in samples: [HKSample],
+        from start: Date,
+        to end: Date,
+        expectedInterval: TimeInterval
+    ) -> [TimeWindow] {
+        guard !samples.isEmpty else {
+            return [TimeWindow(start: start, end: end)]
+        }
+
+        var gaps: [TimeWindow] = []
+        let sortedSamples = samples.sorted { $0.startDate < $1.startDate }
+
+        // Check gap at beginning
+        if let firstSample = sortedSamples.first,
+           firstSample.startDate.timeIntervalSince(start) > expectedInterval * 2 {
+            gaps.append(TimeWindow(start: start, end: firstSample.startDate))
+        }
+
+        // Check gaps between samples
+        for i in 0..<(sortedSamples.count - 1) {
+            let currentEnd = sortedSamples[i].endDate
+            let nextStart = sortedSamples[i + 1].startDate
+            let gap = nextStart.timeIntervalSince(currentEnd)
+
+            if gap > expectedInterval * 2 {
+                gaps.append(TimeWindow(start: currentEnd, end: nextStart))
+            }
+        }
+
+        // Check gap at end
+        if let lastSample = sortedSamples.last,
+           end.timeIntervalSince(lastSample.endDate) > expectedInterval * 2 {
+            gaps.append(TimeWindow(start: lastSample.endDate, end: end))
+        }
+
+        return gaps
+    }
+
+    // MARK: - Priority Management
+
+    func setPriority(_ priority: Int, for source: HealthSource, dataType: HealthDataType) {
+        guard var profile = sourceProfiles[source.bundleIdentifier] else { return }
+        profile.priorities[dataType] = priority
+        sourceProfiles[source.bundleIdentifier] = profile
+        storage.saveSourceProfiles(sourceProfiles)
+    }
+
+    func getPriority(for source: HealthSource, dataType: HealthDataType) -> Int {
+        if let profile = sourceProfiles[source.bundleIdentifier],
+           let priority = profile.priorities[dataType] {
+            return priority
+        }
+        return source.category.priority
+    }
+
+    func getSourcesByPriority(for dataType: HealthDataType) -> [HealthSource] {
+        return sources
+            .filter { $0.supportedDataTypes.contains(dataType) }
+            .sorted { getPriority(for: $0, dataType: dataType) > getPriority(for: $1, dataType: dataType) }
+    }
+
+    // MARK: - Source Enable/Disable
+
+    func setEnabled(_ enabled: Bool, for source: HealthSource) {
+        guard var profile = sourceProfiles[source.bundleIdentifier] else { return }
+        profile.isEnabled = enabled
+        sourceProfiles[source.bundleIdentifier] = profile
+        storage.saveSourceProfiles(sourceProfiles)
+    }
+
+    func isEnabled(_ source: HealthSource) -> Bool {
+        return sourceProfiles[source.bundleIdentifier]?.isEnabled ?? true
+    }
+}
+
+// MARK: - Source Profile
+struct SourceProfile: Codable {
+    let bundleIdentifier: String
+    var priorities: [HealthDataType: Int]
+    var isEnabled: Bool
+    var customName: String?
+    var notes: String?
+    let addedAt: Date
+
+    init(source: HealthSource) {
+        self.bundleIdentifier = source.bundleIdentifier
+        self.priorities = [:]
+        self.isEnabled = true
+        self.customName = nil
+        self.notes = nil
+        self.addedAt = Date()
+    }
+}
+
+// MARK: - Source Capabilities
+struct SourceCapabilities {
+    let canMeasureSteps: Bool
+    let canMeasureDistance: Bool
+    let canMeasureFloors: Bool
+    let canMeasureHeartRate: Bool
+    let canMeasureBloodPressure: Bool
+    let canMeasureBloodOxygen: Bool
+    let canMeasureSleep: Bool
+    let canMeasureWorkouts: Bool
+    let hasGPS: Bool
+    let hasBarometer: Bool
+    let hasAccelerometer: Bool
+
+    static let empty = SourceCapabilities(
+        canMeasureSteps: false,
+        canMeasureDistance: false,
+        canMeasureFloors: false,
+        canMeasureHeartRate: false,
+        canMeasureBloodPressure: false,
+        canMeasureBloodOxygen: false,
+        canMeasureSleep: false,
+        canMeasureWorkouts: false,
+        hasGPS: false,
+        hasBarometer: false,
+        hasAccelerometer: false
+    )
+
+    var supportedDataTypes: Set<HealthDataType> {
+        var types = Set<HealthDataType>()
+        if canMeasureSteps { types.insert(.steps) }
+        if canMeasureDistance { types.insert(.distance) }
+        if canMeasureFloors { types.insert(.floorsClimbed) }
+        if canMeasureHeartRate {
+            types.insert(.heartRate)
+            types.insert(.restingHeartRate)
+        }
+        if canMeasureBloodPressure {
+            types.insert(.bloodPressureSystolic)
+            types.insert(.bloodPressureDiastolic)
+        }
+        if canMeasureBloodOxygen { types.insert(.bloodOxygen) }
+        if canMeasureSleep { types.insert(.sleep) }
+        return types
+    }
+}
+
+// MARK: - Source Health Report
+struct SourceHealthReport {
+    let source: HealthSource
+    let lastActivityByType: [HealthDataType: Date]
+    let recordCountByType: [HealthDataType: Int]
+    let dataGaps: [HealthDataType: [TimeWindow]]
+    let overallQuality: DataQuality
+    let checkedAt: Date
+
+    var lastOverallActivity: Date? {
+        lastActivityByType.values.max()
+    }
+
+    var totalRecordCount: Int {
+        recordCountByType.values.reduce(0, +)
+    }
+
+    var hasSignificantGaps: Bool {
+        dataGaps.values.flatMap { $0 }.contains { $0.duration > 3600 } // > 1 hour gap
+    }
+}
+
+// MARK: - Source Storage Manager
+class SourceStorageManager {
+    private let userDefaults = UserDefaults.standard
+    private let profilesKey = "healthbridge.source.profiles"
+
+    func saveSourceProfiles(_ profiles: [String: SourceProfile]) {
+        do {
+            let data = try JSONEncoder().encode(profiles)
+            userDefaults.set(data, forKey: profilesKey)
+        } catch {
+            print("Failed to save source profiles: \(error)")
+        }
+    }
+
+    func loadSourceProfiles() -> [String: SourceProfile] {
+        guard let data = userDefaults.data(forKey: profilesKey) else {
+            return [:]
+        }
+
+        do {
+            return try JSONDecoder().decode([String: SourceProfile].self, from: data)
+        } catch {
+            print("Failed to load source profiles: \(error)")
+            return [:]
+        }
+    }
+}

HealthBridge/Services/SyncCoordinator.swift

@@ -0,0 +1,301 @@
+import Foundation
+import Combine
+import UserNotifications
+
+// MARK: - Sync Coordinator
+@MainActor
+class SyncCoordinator: ObservableObject {
+    static let shared = SyncCoordinator()
+
+    private let healthKitManager = HealthKitManager.shared
+    private let sourceManager = SourceManager.shared
+    private let dataReader = DataReader.shared
+    private let ruleEngine = RuleEngine.shared
+    private let mergeEngine = MergeEngine.shared
+    private let dataWriter = DataWriter.shared
+
+    @Published var isSyncing = false
+    @Published var syncProgress: Double = 0
+    @Published var lastSyncDate: Date?
+    @Published var lastSyncResult: SyncResult?
+    @Published var pendingConflicts: [Conflict] = []
+    @Published var syncHistory: [SyncResult] = []
+
+    private let syncHistoryKey = "healthbridge.sync.history"
+    private let maxHistoryItems = 50
+
+    private init() {
+        loadSyncHistory()
+    }
+
+    // MARK: - Main Sync
+
+    func performSync(
+        for date: Date = Date(),
+        dataTypes: [HealthDataType] = HealthDataType.allCases
+    ) async throws {
+        guard !isSyncing else { return }
+
+        isSyncing = true
+        syncProgress = 0
+        defer { isSyncing = false }
+
+        let startTime = Date()
+        var result = SyncResult(startedAt: startTime)
+
+        do {
+            // Step 1: Refresh sources (10%)
+            syncProgress = 0.05
+            await sourceManager.discoverSources()
+            syncProgress = 0.1
+
+            // Step 2: Detect conflicts (40%)
+            let conflicts = try await dataReader.detectConflicts(for: date, dataTypes: dataTypes)
+            result.totalConflicts = conflicts.count
+            syncProgress = 0.4
+
+            // Step 3: Process conflicts with merge engine (70%)
+            let operations = await mergeEngine.processConflicts(conflicts)
+            syncProgress = 0.7
+
+            let autoResolved = operations.filter { $0.status == .resolved }
+            let pendingManual = operations.filter { $0.status == .pendingManualReview }
+
+            result.autoResolved = autoResolved.count
+            result.pendingManualReview = pendingManual.count
+
+            // Update pending conflicts
+            pendingConflicts = pendingManual.map { $0.conflict }
+
+            // Step 4: Write resolved records (90%)
+            let recordsToWrite = autoResolved.compactMap { $0.mergedRecord }
+            if !recordsToWrite.isEmpty {
+                let writeResult = await dataWriter.writeBatch(recordsToWrite)
+                result.writtenRecords = writeResult.successCount
+                result.writeErrors = writeResult.failureCount
+            }
+            syncProgress = 0.9
+
+            // Step 5: Finalize (100%)
+            result.completedAt = Date()
+            result.status = .success
+            syncProgress = 1.0
+
+        } catch {
+            result.status = .failed
+            result.error = error.localizedDescription
+            result.completedAt = Date()
+            throw error
+        }
+
+        lastSyncDate = Date()
+        lastSyncResult = result
+        addToHistory(result)
+
+        // Send notification if there are pending conflicts
+        if result.pendingManualReview > 0 {
+            await sendConflictNotification(count: result.pendingManualReview)
+        }
+    }
+
+    // MARK: - Quick Sync
+
+    func performQuickSync() async throws {
+        try await performSync(
+            for: Date(),
+            dataTypes: [.steps, .heartRate, .activeEnergy]
+        )
+    }
+
+    // MARK: - Sync Specific Data Type
+
+    func syncDataType(_ dataType: HealthDataType, for date: Date = Date()) async throws {
+        try await performSync(for: date, dataTypes: [dataType])
+    }
+
+    // MARK: - Manual Conflict Resolution
+
+    func resolveConflict(_ conflict: Conflict, selectedReadingId: UUID) async throws {
+        guard let resolution = mergeEngine.resolveConflictManually(conflict, selectedReadingId: selectedReadingId) else {
+            throw SyncError.resolutionFailed
+        }
+
+        var resolvedConflict = conflict
+        resolvedConflict.status = .resolved
+        resolvedConflict.resolution = resolution
+        resolvedConflict.resolvedAt = Date()
+
+        let mergedRecord = mergeEngine.createMergedRecord(from: resolvedConflict, resolution: resolution)
+
+        // Write the record
+        _ = try await dataWriter.writeRecord(mergedRecord)
+
+        // Remove from pending
+        pendingConflicts.removeAll { $0.id == conflict.id }
+    }
+
+    func ignoreConflict(_ conflict: Conflict) {
+        pendingConflicts.removeAll { $0.id == conflict.id }
+    }
+
+    // MARK: - Sync History
+
+    private func loadSyncHistory() {
+        guard let data = UserDefaults.standard.data(forKey: syncHistoryKey),
+              let history = try? JSONDecoder().decode([SyncResult].self, from: data) else {
+            return
+        }
+        syncHistory = history
+    }
+
+    private func addToHistory(_ result: SyncResult) {
+        syncHistory.insert(result, at: 0)
+        if syncHistory.count > maxHistoryItems {
+            syncHistory = Array(syncHistory.prefix(maxHistoryItems))
+        }
+        saveSyncHistory()
+    }
+
+    private func saveSyncHistory() {
+        guard let data = try? JSONEncoder().encode(syncHistory) else { return }
+        UserDefaults.standard.set(data, forKey: syncHistoryKey)
+    }
+
+    func clearHistory() {
+        syncHistory.removeAll()
+        UserDefaults.standard.removeObject(forKey: syncHistoryKey)
+    }
+
+    // MARK: - Notifications
+
+    private func sendConflictNotification(count: Int) async {
+        let center = UNUserNotificationCenter.current()
+
+        let settings = await center.notificationSettings()
+        guard settings.authorizationStatus == .authorized else { return }
+
+        let content = UNMutableNotificationContent()
+        content.title = "HealthBridge"
+        content.body = count == 1
+            ? "1 Konflikt erfordert Ihre Aufmerksamkeit"
+            : "\(count) Konflikte erfordern Ihre Aufmerksamkeit"
+        content.sound = .default
+        content.badge = NSNumber(value: count)
+
+        let request = UNNotificationRequest(
+            identifier: "healthbridge.conflicts",
+            content: content,
+            trigger: nil
+        )
+
+        try? await center.add(request)
+    }
+
+    func requestNotificationPermission() async -> Bool {
+        let center = UNUserNotificationCenter.current()
+
+        do {
+            return try await center.requestAuthorization(options: [.alert, .sound, .badge])
+        } catch {
+            return false
+        }
+    }
+
+    // MARK: - Statistics
+
+    var todayStats: TodayStats {
+        let today = Calendar.current.startOfDay(for: Date())
+        let todaySyncs = syncHistory.filter {
+            Calendar.current.isDate($0.startedAt, inSameDayAs: today)
+        }
+
+        return TodayStats(
+            syncCount: todaySyncs.count,
+            totalConflicts: todaySyncs.reduce(0) { $0 + $1.totalConflicts },
+            autoResolved: todaySyncs.reduce(0) { $0 + $1.autoResolved },
+            pendingManual: pendingConflicts.count,
+            lastSync: lastSyncDate
+        )
+    }
+}
+
+// MARK: - Supporting Types
+
+struct SyncResult: Identifiable, Codable {
+    let id = UUID()
+    let startedAt: Date
+    var completedAt: Date?
+    var status: SyncStatus = .inProgress
+    var totalConflicts = 0
+    var autoResolved = 0
+    var pendingManualReview = 0
+    var writtenRecords = 0
+    var writeErrors = 0
+    var error: String?
+
+    enum SyncStatus: String, Codable {
+        case inProgress = "in_progress"
+        case success = "success"
+        case partialSuccess = "partial_success"
+        case failed = "failed"
+    }
+
+    var duration: TimeInterval? {
+        guard let completed = completedAt else { return nil }
+        return completed.timeIntervalSince(startedAt)
+    }
+
+    var formattedDuration: String {
+        guard let duration = duration else { return "–" }
+        if duration < 1 {
+            return "< 1s"
+        }
+        return String(format: "%.1fs", duration)
+    }
+
+    var successRate: Double {
+        guard totalConflicts > 0 else { return 1.0 }
+        return Double(autoResolved) / Double(totalConflicts)
+    }
+}
+
+struct TodayStats {
+    let syncCount: Int
+    let totalConflicts: Int
+    let autoResolved: Int
+    let pendingManual: Int
+    let lastSync: Date?
+
+    var resolutionRate: Double {
+        guard totalConflicts > 0 else { return 1.0 }
+        return Double(autoResolved) / Double(totalConflicts)
+    }
+
+    var formattedLastSync: String {
+        guard let date = lastSync else { return "Nie" }
+
+        let formatter = RelativeDateTimeFormatter()
+        formatter.unitsStyle = .abbreviated
+        return formatter.localizedString(for: date, relativeTo: Date())
+    }
+}
+
+enum SyncError: LocalizedError {
+    case notAuthorized
+    case syncInProgress
+    case resolutionFailed
+    case writeFailed
+
+    var errorDescription: String? {
+        switch self {
+        case .notAuthorized:
+            return "Keine Berechtigung für HealthKit"
+        case .syncInProgress:
+            return "Synchronisierung läuft bereits"
+        case .resolutionFailed:
+            return "Konfliktauflösung fehlgeschlagen"
+        case .writeFailed:
+            return "Schreiben der Daten fehlgeschlagen"
+        }
+    }
+}

HealthBridge/Utils/Extensions.swift

@@ -0,0 +1,153 @@
+import Foundation
+import SwiftUI
+
+// MARK: - Date Extensions
+extension Date {
+    var startOfDay: Date {
+        Calendar.current.startOfDay(for: self)
+    }
+
+    var endOfDay: Date {
+        Calendar.current.date(byAdding: .day, value: 1, to: startOfDay)!.addingTimeInterval(-1)
+    }
+
+    var isToday: Bool {
+        Calendar.current.isDateInToday(self)
+    }
+
+    var isYesterday: Bool {
+        Calendar.current.isDateInYesterday(self)
+    }
+
+    func formatted(style: DateFormatter.Style) -> String {
+        let formatter = DateFormatter()
+        formatter.dateStyle = style
+        formatter.timeStyle = .none
+        return formatter.string(from: self)
+    }
+
+    func formattedTime() -> String {
+        let formatter = DateFormatter()
+        formatter.dateStyle = .none
+        formatter.timeStyle = .short
+        return formatter.string(from: self)
+    }
+
+    func formattedRelative() -> String {
+        let formatter = RelativeDateTimeFormatter()
+        formatter.unitsStyle = .abbreviated
+        return formatter.localizedString(for: self, relativeTo: Date())
+    }
+
+    func adding(days: Int) -> Date {
+        Calendar.current.date(byAdding: .day, value: days, to: self)!
+    }
+
+    func adding(hours: Int) -> Date {
+        Calendar.current.date(byAdding: .hour, value: hours, to: self)!
+    }
+
+    func adding(minutes: Int) -> Date {
+        Calendar.current.date(byAdding: .minute, value: minutes, to: self)!
+    }
+}
+
+// MARK: - Double Extensions
+extension Double {
+    func formatted(decimals: Int = 1) -> String {
+        String(format: "%.\(decimals)f", self)
+    }
+
+    var formattedAsInteger: String {
+        String(format: "%.0f", self)
+    }
+
+    var formattedAsPercentage: String {
+        String(format: "%.1f%%", self * 100)
+    }
+}
+
+// MARK: - Array Extensions
+extension Array {
+    func chunked(into size: Int) -> [[Element]] {
+        stride(from: 0, to: count, by: size).map {
+            Array(self[$0..<Swift.min($0 + size, count)])
+        }
+    }
+}
+
+// MARK: - Color Extensions
+extension Color {
+    static let healthBridgePrimary = Color.blue
+    static let healthBridgeSecondary = Color.cyan
+    static let healthBridgeAccent = Color.orange
+
+    static func forSeverity(_ severity: ConflictSeverity) -> Color {
+        switch severity {
+        case .minor: return .green
+        case .moderate: return .yellow
+        case .significant: return .orange
+        case .major: return .red
+        }
+    }
+
+    static func forQuality(_ quality: DataQuality) -> Color {
+        switch quality {
+        case .complete: return .green
+        case .partial: return .yellow
+        case .missing: return .gray
+        case .invalid: return .red
+        }
+    }
+}
+
+// MARK: - View Extensions
+extension View {
+    func cardStyle() -> some View {
+        self
+            .padding()
+            .background(Color(.systemBackground))
+            .clipShape(RoundedRectangle(cornerRadius: 12))
+            .shadow(color: .black.opacity(0.05), radius: 4, y: 2)
+    }
+
+    func sectionHeader(_ title: String) -> some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text(title)
+                .font(.headline)
+                .foregroundStyle(.primary)
+            self
+        }
+    }
+}
+
+// MARK: - Binding Extensions
+extension Binding {
+    func onChange(_ handler: @escaping (Value) -> Void) -> Binding<Value> {
+        Binding(
+            get: { self.wrappedValue },
+            set: { newValue in
+                self.wrappedValue = newValue
+                handler(newValue)
+            }
+        )
+    }
+}
+
+// MARK: - Optional Extensions
+extension Optional where Wrapped == String {
+    var orEmpty: String {
+        self ?? ""
+    }
+
+    var isNilOrEmpty: Bool {
+        self?.isEmpty ?? true
+    }
+}
+
+// MARK: - Collection Extensions
+extension Collection {
+    var isNotEmpty: Bool {
+        !isEmpty
+    }
+}

HealthBridge/Utils/NotificationManager.swift

@@ -0,0 +1,185 @@
+import Foundation
+import UserNotifications
+
+@MainActor
+class NotificationManager: ObservableObject {
+    static let shared = NotificationManager()
+
+    @Published var isAuthorized = false
+    @Published var pendingNotifications: [String] = []
+
+    private let center = UNUserNotificationCenter.current()
+
+    private init() {
+        Task {
+            await checkAuthorization()
+        }
+    }
+
+    // MARK: - Authorization
+
+    func requestAuthorization() async -> Bool {
+        do {
+            let granted = try await center.requestAuthorization(options: [.alert, .sound, .badge])
+            isAuthorized = granted
+            return granted
+        } catch {
+            print("Notification authorization failed: \(error)")
+            return false
+        }
+    }
+
+    func checkAuthorization() async {
+        let settings = await center.notificationSettings()
+        isAuthorized = settings.authorizationStatus == .authorized
+    }
+
+    // MARK: - Conflict Notifications
+
+    func sendConflictNotification(count: Int) async {
+        guard isAuthorized else { return }
+
+        let content = UNMutableNotificationContent()
+        content.title = "HealthBridge"
+
+        if count == 1 {
+            content.body = "1 neuer Konflikt erfordert Ihre Aufmerksamkeit"
+        } else {
+            content.body = "\(count) neue Konflikte erfordern Ihre Aufmerksamkeit"
+        }
+
+        content.sound = .default
+        content.badge = NSNumber(value: count)
+        content.categoryIdentifier = "CONFLICT"
+
+        let request = UNNotificationRequest(
+            identifier: "healthbridge.conflict.\(Date().timeIntervalSince1970)",
+            content: content,
+            trigger: nil
+        )
+
+        do {
+            try await center.add(request)
+        } catch {
+            print("Failed to send notification: \(error)")
+        }
+    }
+
+    // MARK: - Sync Notifications
+
+    func sendSyncCompleteNotification(
+        conflictsResolved: Int,
+        pendingConflicts: Int
+    ) async {
+        guard isAuthorized else { return }
+
+        let content = UNMutableNotificationContent()
+        content.title = "Sync abgeschlossen"
+
+        if pendingConflicts > 0 {
+            content.body = "\(conflictsResolved) Konflikte gelöst, \(pendingConflicts) offen"
+        } else {
+            content.body = "Alle \(conflictsResolved) Konflikte wurden gelöst"
+        }
+
+        content.sound = .default
+        content.categoryIdentifier = "SYNC_COMPLETE"
+
+        let request = UNNotificationRequest(
+            identifier: "healthbridge.sync.\(Date().timeIntervalSince1970)",
+            content: content,
+            trigger: nil
+        )
+
+        do {
+            try await center.add(request)
+        } catch {
+            print("Failed to send notification: \(error)")
+        }
+    }
+
+    // MARK: - Scheduled Notifications
+
+    func scheduleReminder(at hour: Int, minute: Int) async {
+        guard isAuthorized else { return }
+
+        let content = UNMutableNotificationContent()
+        content.title = "HealthBridge Erinnerung"
+        content.body = "Vergessen Sie nicht, Ihre Gesundheitsdaten zu synchronisieren"
+        content.sound = .default
+
+        var dateComponents = DateComponents()
+        dateComponents.hour = hour
+        dateComponents.minute = minute
+
+        let trigger = UNCalendarNotificationTrigger(dateMatching: dateComponents, repeats: true)
+
+        let request = UNNotificationRequest(
+            identifier: "healthbridge.reminder.daily",
+            content: content,
+            trigger: trigger
+        )
+
+        do {
+            try await center.add(request)
+        } catch {
+            print("Failed to schedule reminder: \(error)")
+        }
+    }
+
+    func cancelReminder() {
+        center.removePendingNotificationRequests(withIdentifiers: ["healthbridge.reminder.daily"])
+    }
+
+    // MARK: - Badge Management
+
+    func clearBadge() async {
+        do {
+            try await center.setBadgeCount(0)
+        } catch {
+            print("Failed to clear badge: \(error)")
+        }
+    }
+
+    func updateBadge(count: Int) async {
+        do {
+            try await center.setBadgeCount(count)
+        } catch {
+            print("Failed to update badge: \(error)")
+        }
+    }
+
+    // MARK: - Notification Categories
+
+    func registerCategories() {
+        // Conflict category with actions
+        let resolveAction = UNNotificationAction(
+            identifier: "RESOLVE_AUTO",
+            title: "Automatisch lösen",
+            options: []
+        )
+
+        let viewAction = UNNotificationAction(
+            identifier: "VIEW_CONFLICTS",
+            title: "Anzeigen",
+            options: [.foreground]
+        )
+
+        let conflictCategory = UNNotificationCategory(
+            identifier: "CONFLICT",
+            actions: [resolveAction, viewAction],
+            intentIdentifiers: [],
+            options: []
+        )
+
+        // Sync complete category
+        let syncCategory = UNNotificationCategory(
+            identifier: "SYNC_COMPLETE",
+            actions: [viewAction],
+            intentIdentifiers: [],
+            options: []
+        )
+
+        center.setNotificationCategories([conflictCategory, syncCategory])
+    }
+}

HealthBridge/ViewModels/DashboardViewModel.swift

@@ -0,0 +1,103 @@
+import Foundation
+import Combine
+
+@MainActor
+class DashboardViewModel: ObservableObject {
+    private let syncCoordinator = SyncCoordinator.shared
+    private let dataReader = DataReader.shared
+    private let sourceManager = SourceManager.shared
+
+    @Published var dailySummary: DailySummary?
+    @Published var isLoading = false
+    @Published var selectedDate = Date()
+    @Published var errorMessage: String?
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init() {
+        setupBindings()
+    }
+
+    private func setupBindings() {
+        $selectedDate
+            .debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
+            .sink { [weak self] date in
+                Task {
+                    await self?.loadData(for: date)
+                }
+            }
+            .store(in: &cancellables)
+    }
+
+    func loadData(for date: Date = Date()) async {
+        isLoading = true
+        errorMessage = nil
+
+        do {
+            dailySummary = try await dataReader.fetchDailySummary(for: date)
+        } catch {
+            errorMessage = error.localizedDescription
+        }
+
+        isLoading = false
+    }
+
+    func performSync() async {
+        do {
+            try await syncCoordinator.performSync(for: selectedDate)
+            await loadData(for: selectedDate)
+        } catch {
+            errorMessage = "Sync fehlgeschlagen: \(error.localizedDescription)"
+        }
+    }
+
+    func refresh() async {
+        await sourceManager.discoverSources()
+        await loadData(for: selectedDate)
+    }
+
+    var syncStatus: SyncStatus {
+        if syncCoordinator.isSyncing {
+            return .syncing
+        } else if let lastSync = syncCoordinator.lastSyncDate {
+            let hoursSinceSync = Date().timeIntervalSince(lastSync) / 3600
+            if hoursSinceSync < 1 {
+                return .synced
+            } else if hoursSinceSync < 24 {
+                return .stale
+            } else {
+                return .veryStale
+            }
+        } else {
+            return .neverSynced
+        }
+    }
+
+    enum SyncStatus {
+        case syncing
+        case synced
+        case stale
+        case veryStale
+        case neverSynced
+
+        var description: String {
+            switch self {
+            case .syncing: return "Synchronisiere..."
+            case .synced: return "Synchronisiert"
+            case .stale: return "Sync empfohlen"
+            case .veryStale: return "Sync überfällig"
+            case .neverSynced: return "Nie synchronisiert"
+            }
+        }
+
+        var icon: String {
+            switch self {
+            case .syncing: return "arrow.triangle.2.circlepath"
+            case .synced: return "checkmark.circle.fill"
+            case .stale: return "exclamationmark.circle"
+            case .veryStale: return "exclamationmark.triangle"
+            case .neverSynced: return "xmark.circle"
+            }
+        }
+    }
+}

HealthBridge/Views/Components/HealthChart.swift

@@ -0,0 +1,241 @@
+import SwiftUI
+import Charts
+
+struct HealthChart: View {
+    let dataType: HealthDataType
+    let data: [ChartDataPoint]
+    let showConflicts: Bool
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Image(systemName: dataType.icon)
+                    .foregroundStyle(.blue)
+                Text(dataType.displayName)
+                    .font(.headline)
+                Spacer()
+                if let latest = data.last {
+                    Text(latest.formattedValue)
+                        .font(.title3)
+                        .fontWeight(.semibold)
+                    Text(dataType.unit)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+            }
+
+            if #available(iOS 16.0, *) {
+                Chart(data) { point in
+                    LineMark(
+                        x: .value("Zeit", point.date),
+                        y: .value("Wert", point.value)
+                    )
+                    .foregroundStyle(.blue)
+
+                    PointMark(
+                        x: .value("Zeit", point.date),
+                        y: .value("Wert", point.value)
+                    )
+                    .foregroundStyle(point.hasConflict && showConflicts ? .orange : .blue)
+                    .symbolSize(point.hasConflict && showConflicts ? 100 : 50)
+                }
+                .frame(height: 150)
+                .chartXAxis {
+                    AxisMarks(values: .stride(by: .hour, count: 4)) { value in
+                        AxisValueLabel(format: .dateTime.hour())
+                    }
+                }
+                .chartYAxis {
+                    AxisMarks(position: .leading)
+                }
+            } else {
+                // Fallback for iOS 15
+                simpleChart
+            }
+        }
+        .padding()
+        .background(Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+
+    private var simpleChart: some View {
+        GeometryReader { geometry in
+            let maxValue = data.map { $0.value }.max() ?? 1
+            let minValue = data.map { $0.value }.min() ?? 0
+            let range = maxValue - minValue
+
+            Path { path in
+                guard !data.isEmpty else { return }
+
+                let xStep = geometry.size.width / CGFloat(max(1, data.count - 1))
+
+                for (index, point) in data.enumerated() {
+                    let x = CGFloat(index) * xStep
+                    let normalizedY = range > 0 ? (point.value - minValue) / range : 0.5
+                    let y = geometry.size.height * (1 - normalizedY)
+
+                    if index == 0 {
+                        path.move(to: CGPoint(x: x, y: y))
+                    } else {
+                        path.addLine(to: CGPoint(x: x, y: y))
+                    }
+                }
+            }
+            .stroke(Color.blue, lineWidth: 2)
+        }
+        .frame(height: 150)
+    }
+}
+
+struct ChartDataPoint: Identifiable {
+    let id = UUID()
+    let date: Date
+    let value: Double
+    let hasConflict: Bool
+    let sourceId: String?
+
+    var formattedValue: String {
+        if value == floor(value) {
+            return String(format: "%.0f", value)
+        }
+        return String(format: "%.1f", value)
+    }
+}
+
+// MARK: - Blood Pressure Chart
+struct BloodPressureChart: View {
+    let data: [BloodPressurePoint]
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Image(systemName: "drop.fill")
+                    .foregroundStyle(.red)
+                Text("Blutdruck")
+                    .font(.headline)
+                Spacer()
+                if let latest = data.last {
+                    Text("\(Int(latest.systolic))/\(Int(latest.diastolic))")
+                        .font(.title3)
+                        .fontWeight(.semibold)
+                    Text("mmHg")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+            }
+
+            if #available(iOS 16.0, *) {
+                Chart(data) { point in
+                    // Systolic
+                    LineMark(
+                        x: .value("Zeit", point.date),
+                        y: .value("Systolisch", point.systolic)
+                    )
+                    .foregroundStyle(.red)
+
+                    // Diastolic
+                    LineMark(
+                        x: .value("Zeit", point.date),
+                        y: .value("Diastolisch", point.diastolic)
+                    )
+                    .foregroundStyle(.blue)
+                }
+                .frame(height: 150)
+                .chartYScale(domain: 40...180)
+                .chartLegend(position: .bottom)
+            }
+        }
+        .padding()
+        .background(Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+}
+
+struct BloodPressurePoint: Identifiable {
+    let id = UUID()
+    let date: Date
+    let systolic: Double
+    let diastolic: Double
+    let classification: BloodPressureHandler.BloodPressureClassification
+}
+
+// MARK: - Summary Ring
+struct SummaryRing: View {
+    let progress: Double
+    let color: Color
+    let icon: String
+    let value: String
+    let label: String
+
+    var body: some View {
+        VStack(spacing: 4) {
+            ZStack {
+                Circle()
+                    .stroke(color.opacity(0.2), lineWidth: 8)
+
+                Circle()
+                    .trim(from: 0, to: min(progress, 1.0))
+                    .stroke(color, style: StrokeStyle(lineWidth: 8, lineCap: .round))
+                    .rotationEffect(.degrees(-90))
+
+                VStack(spacing: 2) {
+                    Image(systemName: icon)
+                        .font(.caption)
+                        .foregroundStyle(color)
+                    Text(value)
+                        .font(.caption2)
+                        .fontWeight(.semibold)
+                }
+            }
+            .frame(width: 60, height: 60)
+
+            Text(label)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+    }
+}
+
+#Preview {
+    VStack(spacing: 20) {
+        HealthChart(
+            dataType: .steps,
+            data: (0..<24).map { hour in
+                ChartDataPoint(
+                    date: Calendar.current.date(byAdding: .hour, value: hour, to: Calendar.current.startOfDay(for: Date()))!,
+                    value: Double.random(in: 0...1000),
+                    hasConflict: hour % 5 == 0,
+                    sourceId: nil
+                )
+            },
+            showConflicts: true
+        )
+
+        HStack(spacing: 20) {
+            SummaryRing(
+                progress: 0.75,
+                color: .blue,
+                icon: "figure.walk",
+                value: "7.5k",
+                label: "Schritte"
+            )
+
+            SummaryRing(
+                progress: 0.5,
+                color: .red,
+                icon: "heart.fill",
+                value: "72",
+                label: "Puls"
+            )
+
+            SummaryRing(
+                progress: 1.0,
+                color: .green,
+                icon: "checkmark.circle",
+                value: "100%",
+                label: "Synced"
+            )
+        }
+    }
+    .padding()
+}

HealthBridge/Views/ConflictsView.swift

@@ -0,0 +1,348 @@
+import SwiftUI
+
+struct ConflictsView: View {
+    @EnvironmentObject var syncCoordinator: SyncCoordinator
+    @State private var selectedConflict: Conflict?
+    @State private var showingDetail = false
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if syncCoordinator.pendingConflicts.isEmpty {
+                    emptyState
+                } else {
+                    conflictsList
+                }
+            }
+            .navigationTitle("Konflikte")
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Menu {
+                        Button("Alle automatisch lösen") {
+                            Task { await resolveAllAuto() }
+                        }
+                        Button("Alle ignorieren", role: .destructive) {
+                            ignoreAll()
+                        }
+                    } label: {
+                        Image(systemName: "ellipsis.circle")
+                    }
+                    .disabled(syncCoordinator.pendingConflicts.isEmpty)
+                }
+            }
+            .sheet(item: $selectedConflict) { conflict in
+                ConflictDetailView(conflict: conflict) { selectedReadingId in
+                    Task {
+                        await resolveConflict(conflict, selectedReadingId: selectedReadingId)
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Empty State
+
+    private var emptyState: some View {
+        VStack(spacing: 16) {
+            Image(systemName: "checkmark.circle.fill")
+                .font(.system(size: 64))
+                .foregroundStyle(.green)
+
+            Text("Keine Konflikte")
+                .font(.title2)
+                .fontWeight(.semibold)
+
+            Text("Alle Ihre Gesundheitsdaten sind synchronisiert")
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+        }
+        .padding()
+    }
+
+    // MARK: - Conflicts List
+
+    private var conflictsList: some View {
+        List {
+            ForEach(groupedConflicts.keys.sorted(by: { $0.displayName < $1.displayName }), id: \.self) { dataType in
+                Section(dataType.displayName) {
+                    ForEach(groupedConflicts[dataType] ?? []) { conflict in
+                        ConflictRow(conflict: conflict)
+                            .contentShape(Rectangle())
+                            .onTapGesture {
+                                selectedConflict = conflict
+                            }
+                    }
+                }
+            }
+        }
+        .listStyle(.insetGrouped)
+    }
+
+    private var groupedConflicts: [HealthDataType: [Conflict]] {
+        Dictionary(grouping: syncCoordinator.pendingConflicts, by: { $0.dataType })
+    }
+
+    // MARK: - Actions
+
+    private func resolveConflict(_ conflict: Conflict, selectedReadingId: UUID) async {
+        do {
+            try await syncCoordinator.resolveConflict(conflict, selectedReadingId: selectedReadingId)
+            selectedConflict = nil
+        } catch {
+            print("Failed to resolve conflict: \(error)")
+        }
+    }
+
+    private func resolveAllAuto() async {
+        for conflict in syncCoordinator.pendingConflicts {
+            if let primaryReading = conflict.primarySourceReading {
+                try? await syncCoordinator.resolveConflict(conflict, selectedReadingId: primaryReading.id)
+            }
+        }
+    }
+
+    private func ignoreAll() {
+        for conflict in syncCoordinator.pendingConflicts {
+            syncCoordinator.ignoreConflict(conflict)
+        }
+    }
+}
+
+// MARK: - Conflict Row
+
+struct ConflictRow: View {
+    let conflict: Conflict
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Image(systemName: conflict.dataType.icon)
+                    .foregroundStyle(.blue)
+
+                Text(conflict.timeWindow.formattedRange)
+                    .font(.headline)
+
+                Spacer()
+
+                severityBadge
+            }
+
+            HStack(spacing: 16) {
+                ForEach(conflict.readings.prefix(3)) { reading in
+                    VStack(alignment: .leading, spacing: 2) {
+                        Text(reading.sourceName)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                        Text(reading.formattedValue)
+                            .font(.subheadline)
+                            .fontWeight(.medium)
+                    }
+                }
+            }
+
+            if conflict.readings.count > 3 {
+                Text("+\(conflict.readings.count - 3) weitere")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+        }
+        .padding(.vertical, 4)
+    }
+
+    private var severityBadge: some View {
+        Text(conflict.severity.displayName)
+            .font(.caption2)
+            .padding(.horizontal, 8)
+            .padding(.vertical, 4)
+            .background(severityColor.opacity(0.2))
+            .foregroundStyle(severityColor)
+            .clipShape(Capsule())
+    }
+
+    private var severityColor: Color {
+        switch conflict.severity {
+        case .minor: return .green
+        case .moderate: return .yellow
+        case .significant: return .orange
+        case .major: return .red
+        }
+    }
+}
+
+// MARK: - Conflict Detail View
+
+struct ConflictDetailView: View {
+    let conflict: Conflict
+    let onResolve: (UUID) -> Void
+
+    @Environment(\.dismiss) private var dismiss
+    @State private var selectedReadingId: UUID?
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(spacing: 20) {
+                    // Header
+                    headerSection
+
+                    // Readings
+                    readingsSection
+
+                    // Difference Info
+                    differenceSection
+
+                    Spacer()
+                }
+                .padding()
+            }
+            .navigationTitle("Konflikt lösen")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Abbrechen") {
+                        dismiss()
+                    }
+                }
+
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Auswählen") {
+                        if let id = selectedReadingId {
+                            onResolve(id)
+                        }
+                    }
+                    .disabled(selectedReadingId == nil)
+                }
+            }
+        }
+    }
+
+    // MARK: - Header
+
+    private var headerSection: some View {
+        VStack(spacing: 8) {
+            Image(systemName: conflict.dataType.icon)
+                .font(.largeTitle)
+                .foregroundStyle(.blue)
+
+            Text(conflict.dataType.displayName)
+                .font(.title2)
+                .fontWeight(.semibold)
+
+            Text(conflict.timeWindow.formattedDate)
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+
+            Text(conflict.timeWindow.formattedRange)
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+        }
+        .padding()
+    }
+
+    // MARK: - Readings
+
+    private var readingsSection: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Quellen")
+                .font(.headline)
+
+            ForEach(conflict.readings) { reading in
+                ReadingCard(
+                    reading: reading,
+                    isSelected: selectedReadingId == reading.id,
+                    dataType: conflict.dataType
+                )
+                .onTapGesture {
+                    selectedReadingId = reading.id
+                }
+            }
+        }
+    }
+
+    // MARK: - Difference
+
+    private var differenceSection: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text("Analyse")
+                .font(.headline)
+
+            HStack {
+                VStack(alignment: .leading) {
+                    Text("Differenz")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Text(String(format: "%.1f %@", conflict.valueDifference, conflict.dataType.unit))
+                        .font(.title3)
+                        .fontWeight(.medium)
+                }
+
+                Spacer()
+
+                VStack(alignment: .trailing) {
+                    Text("Prozentual")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Text(String(format: "%.1f%%", conflict.percentageDifference))
+                        .font(.title3)
+                        .fontWeight(.medium)
+                }
+            }
+            .padding()
+            .background(Color(.secondarySystemBackground))
+            .clipShape(RoundedRectangle(cornerRadius: 12))
+        }
+    }
+}
+
+// MARK: - Reading Card
+
+struct ReadingCard: View {
+    let reading: SourceReading
+    let isSelected: Bool
+    let dataType: HealthDataType
+
+    var body: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 4) {
+                HStack {
+                    Image(systemName: reading.sourceCategory.icon)
+                        .foregroundStyle(.blue)
+                    Text(reading.sourceName)
+                        .font(.headline)
+                }
+
+                Text(reading.sourceCategory.displayName)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+
+            Spacer()
+
+            VStack(alignment: .trailing, spacing: 4) {
+                Text(reading.formattedValue)
+                    .font(.title2)
+                    .fontWeight(.semibold)
+                Text(dataType.unit)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+
+            Image(systemName: isSelected ? "checkmark.circle.fill" : "circle")
+                .font(.title2)
+                .foregroundStyle(isSelected ? .blue : .secondary)
+        }
+        .padding()
+        .background(isSelected ? Color.blue.opacity(0.1) : Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+        .overlay(
+            RoundedRectangle(cornerRadius: 12)
+                .stroke(isSelected ? Color.blue : Color.clear, lineWidth: 2)
+        )
+    }
+}
+
+#Preview {
+    ConflictsView()
+        .environmentObject(SyncCoordinator.shared)
+}

HealthBridge/Views/ContentView.swift

@@ -0,0 +1,42 @@
+import SwiftUI
+
+struct ContentView: View {
+    @EnvironmentObject var appState: AppState
+    @EnvironmentObject var syncCoordinator: SyncCoordinator
+
+    var body: some View {
+        TabView(selection: $appState.selectedTab) {
+            DashboardView()
+                .tabItem {
+                    Label("Dashboard", systemImage: "chart.bar.fill")
+                }
+                .tag(AppState.Tab.dashboard)
+
+            ConflictsView()
+                .tabItem {
+                    Label("Konflikte", systemImage: "arrow.triangle.2.circlepath")
+                }
+                .tag(AppState.Tab.conflicts)
+                .badge(syncCoordinator.pendingConflicts.count)
+
+            RulesView()
+                .tabItem {
+                    Label("Regeln", systemImage: "slider.horizontal.3")
+                }
+                .tag(AppState.Tab.rules)
+
+            SourcesView()
+                .tabItem {
+                    Label("Quellen", systemImage: "antenna.radiowaves.left.and.right")
+                }
+                .tag(AppState.Tab.sources)
+        }
+        .tint(.blue)
+    }
+}
+
+#Preview {
+    ContentView()
+        .environmentObject(AppState())
+        .environmentObject(SyncCoordinator.shared)
+}

HealthBridge/Views/DashboardView.swift

@@ -0,0 +1,379 @@
+import SwiftUI
+
+struct DashboardView: View {
+    @EnvironmentObject var appState: AppState
+    @EnvironmentObject var syncCoordinator: SyncCoordinator
+    @StateObject private var dataReader = DataReader.shared
+
+    @State private var dailySummary: DailySummary?
+    @State private var isLoading = false
+    @State private var selectedDate = Date()
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(spacing: 20) {
+                    // Sync Status Card
+                    syncStatusCard
+
+                    // Date Picker
+                    datePicker
+
+                    // Health Metrics
+                    if let summary = dailySummary {
+                        healthMetricsGrid(summary: summary)
+                    } else if isLoading {
+                        loadingView
+                    } else {
+                        emptyStateView
+                    }
+
+                    // Pending Conflicts Alert
+                    if !syncCoordinator.pendingConflicts.isEmpty {
+                        pendingConflictsCard
+                    }
+
+                    // Recent Sync History
+                    recentSyncHistory
+                }
+                .padding()
+            }
+            .navigationTitle("HealthBridge")
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button {
+                        Task { await performSync() }
+                    } label: {
+                        if syncCoordinator.isSyncing {
+                            ProgressView()
+                                .scaleEffect(0.8)
+                        } else {
+                            Image(systemName: "arrow.clockwise")
+                        }
+                    }
+                    .disabled(syncCoordinator.isSyncing)
+                }
+            }
+            .refreshable {
+                await loadData()
+            }
+            .task {
+                await loadData()
+            }
+            .onChange(of: selectedDate) {
+                Task { await loadData() }
+            }
+        }
+    }
+
+    // MARK: - Sync Status Card
+
+    private var syncStatusCard: some View {
+        VStack(spacing: 12) {
+            HStack {
+                VStack(alignment: .leading, spacing: 4) {
+                    Text("Heute")
+                        .font(.headline)
+                    Text(syncCoordinator.todayStats.formattedLastSync)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+
+                Spacer()
+
+                if syncCoordinator.isSyncing {
+                    VStack(alignment: .trailing) {
+                        ProgressView(value: syncCoordinator.syncProgress)
+                            .frame(width: 60)
+                        Text("Synchronisiere...")
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
+                    }
+                } else {
+                    Image(systemName: "checkmark.circle.fill")
+                        .font(.title2)
+                        .foregroundStyle(.green)
+                }
+            }
+
+            Divider()
+
+            HStack(spacing: 20) {
+                StatItem(
+                    value: "\(syncCoordinator.todayStats.syncCount)",
+                    label: "Syncs",
+                    icon: "arrow.triangle.2.circlepath"
+                )
+
+                StatItem(
+                    value: "\(syncCoordinator.todayStats.totalConflicts)",
+                    label: "Konflikte",
+                    icon: "exclamationmark.triangle"
+                )
+
+                StatItem(
+                    value: "\(Int(syncCoordinator.todayStats.resolutionRate * 100))%",
+                    label: "Gelöst",
+                    icon: "checkmark.circle"
+                )
+            }
+        }
+        .padding()
+        .background(Color(.systemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 16))
+        .shadow(color: .black.opacity(0.05), radius: 8, y: 4)
+    }
+
+    // MARK: - Date Picker
+
+    private var datePicker: some View {
+        DatePicker(
+            "Datum",
+            selection: $selectedDate,
+            in: ...Date(),
+            displayedComponents: .date
+        )
+        .datePickerStyle(.compact)
+        .padding(.horizontal)
+    }
+
+    // MARK: - Health Metrics Grid
+
+    private func healthMetricsGrid(summary: DailySummary) -> some View {
+        LazyVGrid(columns: [
+            GridItem(.flexible()),
+            GridItem(.flexible())
+        ], spacing: 16) {
+            ForEach(HealthDataType.allCases) { dataType in
+                if let value = summary.values[dataType], value > 0 {
+                    HealthMetricCard(
+                        dataType: dataType,
+                        value: summary.formattedValue(for: dataType),
+                        conflictCount: summary.conflictCounts[dataType] ?? 0
+                    )
+                }
+            }
+        }
+    }
+
+    // MARK: - Pending Conflicts Card
+
+    private var pendingConflictsCard: some View {
+        Button {
+            appState.selectedTab = .conflicts
+        } label: {
+            HStack {
+                Image(systemName: "exclamationmark.triangle.fill")
+                    .foregroundStyle(.orange)
+
+                VStack(alignment: .leading) {
+                    Text("\(syncCoordinator.pendingConflicts.count) Konflikte zu prüfen")
+                        .font(.headline)
+                    Text("Tippen zum Anzeigen")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+
+                Spacer()
+
+                Image(systemName: "chevron.right")
+                    .foregroundStyle(.secondary)
+            }
+            .padding()
+            .background(Color.orange.opacity(0.1))
+            .clipShape(RoundedRectangle(cornerRadius: 12))
+        }
+        .buttonStyle(.plain)
+    }
+
+    // MARK: - Recent Sync History
+
+    private var recentSyncHistory: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Letzte Synchronisierungen")
+                .font(.headline)
+
+            ForEach(syncCoordinator.syncHistory.prefix(5)) { result in
+                SyncHistoryRow(result: result)
+            }
+
+            if syncCoordinator.syncHistory.isEmpty {
+                Text("Keine Synchronisierungen")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+                    .frame(maxWidth: .infinity)
+                    .padding()
+            }
+        }
+        .padding()
+        .background(Color(.systemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 16))
+        .shadow(color: .black.opacity(0.05), radius: 8, y: 4)
+    }
+
+    // MARK: - Loading & Empty States
+
+    private var loadingView: some View {
+        VStack(spacing: 12) {
+            ProgressView()
+            Text("Lade Daten...")
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.vertical, 40)
+    }
+
+    private var emptyStateView: some View {
+        VStack(spacing: 12) {
+            Image(systemName: "heart.text.square")
+                .font(.system(size: 48))
+                .foregroundStyle(.secondary)
+            Text("Keine Daten verfügbar")
+                .font(.headline)
+            Text("Synchronisieren Sie, um Daten zu laden")
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.vertical, 40)
+    }
+
+    // MARK: - Actions
+
+    private func loadData() async {
+        isLoading = true
+        defer { isLoading = false }
+
+        do {
+            dailySummary = try await dataReader.fetchDailySummary(for: selectedDate)
+        } catch {
+            print("Failed to load data: \(error)")
+        }
+    }
+
+    private func performSync() async {
+        do {
+            try await syncCoordinator.performSync(for: selectedDate)
+            await loadData()
+        } catch {
+            print("Sync failed: \(error)")
+        }
+    }
+}
+
+// MARK: - Supporting Views
+
+struct StatItem: View {
+    let value: String
+    let label: String
+    let icon: String
+
+    var body: some View {
+        VStack(spacing: 4) {
+            Image(systemName: icon)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+            Text(value)
+                .font(.title3)
+                .fontWeight(.semibold)
+            Text(label)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+        .frame(maxWidth: .infinity)
+    }
+}
+
+struct HealthMetricCard: View {
+    let dataType: HealthDataType
+    let value: String
+    let conflictCount: Int
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Image(systemName: dataType.icon)
+                    .foregroundStyle(.blue)
+                Spacer()
+                if conflictCount > 0 {
+                    Text("\(conflictCount)")
+                        .font(.caption2)
+                        .padding(.horizontal, 6)
+                        .padding(.vertical, 2)
+                        .background(Color.orange.opacity(0.2))
+                        .clipShape(Capsule())
+                }
+            }
+
+            Text(value)
+                .font(.title2)
+                .fontWeight(.semibold)
+
+            Text(dataType.displayName)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+        .padding()
+        .background(Color(.systemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+        .shadow(color: .black.opacity(0.05), radius: 4, y: 2)
+    }
+}
+
+struct SyncHistoryRow: View {
+    let result: SyncResult
+
+    var body: some View {
+        HStack {
+            Image(systemName: statusIcon)
+                .foregroundStyle(statusColor)
+
+            VStack(alignment: .leading, spacing: 2) {
+                Text(formattedDate)
+                    .font(.subheadline)
+                Text("\(result.autoResolved)/\(result.totalConflicts) gelöst")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+
+            Spacer()
+
+            Text(result.formattedDuration)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+        .padding(.vertical, 4)
+    }
+
+    private var statusIcon: String {
+        switch result.status {
+        case .success: return "checkmark.circle.fill"
+        case .partialSuccess: return "exclamationmark.circle.fill"
+        case .failed: return "xmark.circle.fill"
+        case .inProgress: return "arrow.clockwise"
+        }
+    }
+
+    private var statusColor: Color {
+        switch result.status {
+        case .success: return .green
+        case .partialSuccess: return .orange
+        case .failed: return .red
+        case .inProgress: return .blue
+        }
+    }
+
+    private var formattedDate: String {
+        let formatter = DateFormatter()
+        formatter.dateStyle = .short
+        formatter.timeStyle = .short
+        return formatter.string(from: result.startedAt)
+    }
+}
+
+#Preview {
+    DashboardView()
+        .environmentObject(AppState())
+        .environmentObject(SyncCoordinator.shared)
+}

HealthBridge/Views/RulesView.swift

@@ -0,0 +1,252 @@
+import SwiftUI
+
+struct RulesView: View {
+    @StateObject private var ruleEngine = RuleEngine.shared
+    @StateObject private var sourceManager = SourceManager.shared
+    @State private var selectedDataType: HealthDataType?
+    @State private var showingResetConfirmation = false
+
+    var body: some View {
+        NavigationStack {
+            List {
+                Section {
+                    Text("Regeln bestimmen, wie Konflikte zwischen verschiedenen Datenquellen automatisch gelöst werden.")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+
+                ForEach(HealthDataType.allCases) { dataType in
+                    RuleRow(
+                        dataType: dataType,
+                        rule: ruleEngine.getRule(for: dataType)
+                    )
+                    .contentShape(Rectangle())
+                    .onTapGesture {
+                        selectedDataType = dataType
+                    }
+                }
+            }
+            .listStyle(.insetGrouped)
+            .navigationTitle("Regeln")
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Menu {
+                        Button("Alle zurücksetzen", role: .destructive) {
+                            showingResetConfirmation = true
+                        }
+                    } label: {
+                        Image(systemName: "ellipsis.circle")
+                    }
+                }
+            }
+            .sheet(item: $selectedDataType) { dataType in
+                RuleEditorView(dataType: dataType)
+            }
+            .confirmationDialog(
+                "Alle Regeln zurücksetzen?",
+                isPresented: $showingResetConfirmation,
+                titleVisibility: .visible
+            ) {
+                Button("Zurücksetzen", role: .destructive) {
+                    ruleEngine.resetAllToDefaults()
+                }
+                Button("Abbrechen", role: .cancel) {}
+            } message: {
+                Text("Alle Regeln werden auf die Standardwerte zurückgesetzt.")
+            }
+        }
+    }
+}
+
+// MARK: - Rule Row
+
+struct RuleRow: View {
+    let dataType: HealthDataType
+    let rule: MergeRule
+
+    var body: some View {
+        HStack {
+            Image(systemName: dataType.icon)
+                .foregroundStyle(.blue)
+                .frame(width: 30)
+
+            VStack(alignment: .leading, spacing: 4) {
+                Text(dataType.displayName)
+                    .font(.headline)
+
+                HStack(spacing: 8) {
+                    Image(systemName: rule.strategy.icon)
+                        .font(.caption)
+                    Text(rule.strategy.displayName)
+                        .font(.caption)
+                }
+                .foregroundStyle(.secondary)
+            }
+
+            Spacer()
+
+            if !rule.autoApply {
+                Image(systemName: "hand.raised.fill")
+                    .foregroundStyle(.orange)
+                    .font(.caption)
+            }
+
+            Image(systemName: "chevron.right")
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+        .padding(.vertical, 4)
+    }
+}
+
+// MARK: - Rule Editor View
+
+struct RuleEditorView: View {
+    let dataType: HealthDataType
+    @Environment(\.dismiss) private var dismiss
+    @StateObject private var ruleEngine = RuleEngine.shared
+    @StateObject private var sourceManager = SourceManager.shared
+
+    @State private var selectedStrategy: MergeStrategy
+    @State private var autoApply: Bool
+    @State private var primarySourceId: String?
+    @State private var thresholdForManualReview: Double?
+    @State private var useThreshold: Bool
+
+    init(dataType: HealthDataType) {
+        self.dataType = dataType
+        let rule = RuleEngine.shared.getRule(for: dataType)
+        _selectedStrategy = State(initialValue: rule.strategy)
+        _autoApply = State(initialValue: rule.autoApply)
+        _primarySourceId = State(initialValue: rule.primarySourceId)
+        _thresholdForManualReview = State(initialValue: rule.thresholdForManualReview)
+        _useThreshold = State(initialValue: rule.thresholdForManualReview != nil)
+    }
+
+    var body: some View {
+        NavigationStack {
+            Form {
+                // Data Type Info
+                Section {
+                    HStack {
+                        Image(systemName: dataType.icon)
+                            .font(.title2)
+                            .foregroundStyle(.blue)
+                        VStack(alignment: .leading) {
+                            Text(dataType.displayName)
+                                .font(.headline)
+                            Text(dataType.unit)
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+                }
+
+                // Strategy Selection
+                Section("Strategie") {
+                    Picker("Merge-Strategie", selection: $selectedStrategy) {
+                        ForEach(MergeStrategy.allCases) { strategy in
+                            Label(strategy.displayName, systemImage: strategy.icon)
+                                .tag(strategy)
+                        }
+                    }
+                    .pickerStyle(.navigationLink)
+
+                    Text(selectedStrategy.description)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+
+                // Primary Source (for exclusive/priority)
+                if selectedStrategy == .exclusive || selectedStrategy == .priority {
+                    Section("Primäre Quelle") {
+                        let sources = sourceManager.sources.filter {
+                            $0.supportedDataTypes.contains(dataType)
+                        }
+
+                        if sources.isEmpty {
+                            Text("Keine Quellen für diesen Datentyp")
+                                .foregroundStyle(.secondary)
+                        } else {
+                            Picker("Quelle", selection: $primarySourceId) {
+                                Text("Automatisch").tag(nil as String?)
+                                ForEach(sources) { source in
+                                    Text(source.displayName).tag(source.bundleIdentifier as String?)
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Auto Apply
+                Section("Automatisierung") {
+                    Toggle("Automatisch anwenden", isOn: $autoApply)
+
+                    if autoApply {
+                        Toggle("Schwellenwert für manuelle Prüfung", isOn: $useThreshold)
+
+                        if useThreshold {
+                            VStack(alignment: .leading) {
+                                Text("Bei Differenz über \(Int(thresholdForManualReview ?? 20))% nachfragen")
+                                    .font(.caption)
+                                    .foregroundStyle(.secondary)
+
+                                Slider(
+                                    value: Binding(
+                                        get: { thresholdForManualReview ?? 20 },
+                                        set: { thresholdForManualReview = $0 }
+                                    ),
+                                    in: 5...50,
+                                    step: 5
+                                )
+                            }
+                        }
+                    }
+                }
+
+                // Reset
+                Section {
+                    Button("Auf Standard zurücksetzen", role: .destructive) {
+                        let defaultRule = MergeRule.defaultRule(for: dataType)
+                        selectedStrategy = defaultRule.strategy
+                        autoApply = defaultRule.autoApply
+                        primarySourceId = defaultRule.primarySourceId
+                        thresholdForManualReview = defaultRule.thresholdForManualReview
+                        useThreshold = defaultRule.thresholdForManualReview != nil
+                    }
+                }
+            }
+            .navigationTitle("Regel bearbeiten")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Abbrechen") {
+                        dismiss()
+                    }
+                }
+
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Speichern") {
+                        saveRule()
+                        dismiss()
+                    }
+                }
+            }
+        }
+    }
+
+    private func saveRule() {
+        let rule = MergeRule(
+            dataType: dataType,
+            strategy: selectedStrategy,
+            primarySourceId: primarySourceId,
+            autoApply: autoApply,
+            thresholdForManualReview: useThreshold ? thresholdForManualReview : nil
+        )
+        ruleEngine.setRule(rule, for: dataType)
+    }
+}
+
+#Preview {
+    RulesView()
+}

HealthBridge/Views/SettingsView.swift

@@ -0,0 +1,218 @@
+import SwiftUI
+
+struct SettingsView: View {
+    @AppStorage("backgroundSyncEnabled") private var backgroundSyncEnabled = true
+    @AppStorage("syncIntervalMinutes") private var syncIntervalMinutes = 15
+    @AppStorage("notificationsEnabled") private var notificationsEnabled = true
+    @AppStorage("notifyOnConflict") private var notifyOnConflict = true
+    @AppStorage("notifyOnSyncComplete") private var notifyOnSyncComplete = false
+    @AppStorage("autoResolveMinorConflicts") private var autoResolveMinorConflicts = true
+
+    @StateObject private var syncCoordinator = SyncCoordinator.shared
+    @StateObject private var healthKitManager = HealthKitManager.shared
+
+    @State private var showingClearDataConfirmation = false
+    @State private var showingExportSheet = false
+
+    var body: some View {
+        NavigationStack {
+            Form {
+                // Sync Settings
+                Section("Synchronisierung") {
+                    Toggle("Hintergrund-Sync", isOn: $backgroundSyncEnabled)
+
+                    if backgroundSyncEnabled {
+                        Picker("Intervall", selection: $syncIntervalMinutes) {
+                            Text("15 Minuten").tag(15)
+                            Text("30 Minuten").tag(30)
+                            Text("1 Stunde").tag(60)
+                            Text("2 Stunden").tag(120)
+                        }
+                    }
+
+                    Toggle("Kleine Konflikte automatisch lösen", isOn: $autoResolveMinorConflicts)
+                }
+
+                // Notification Settings
+                Section("Benachrichtigungen") {
+                    Toggle("Benachrichtigungen aktivieren", isOn: $notificationsEnabled)
+
+                    if notificationsEnabled {
+                        Toggle("Bei neuen Konflikten", isOn: $notifyOnConflict)
+                        Toggle("Nach Synchronisierung", isOn: $notifyOnSyncComplete)
+                    }
+                }
+
+                // Health Status
+                Section("HealthKit Status") {
+                    HStack {
+                        Text("Autorisierung")
+                        Spacer()
+                        if healthKitManager.isAuthorized {
+                            Label("Erteilt", systemImage: "checkmark.circle.fill")
+                                .foregroundStyle(.green)
+                        } else {
+                            Label("Ausstehend", systemImage: "exclamationmark.circle")
+                                .foregroundStyle(.orange)
+                        }
+                    }
+
+                    if !healthKitManager.isAuthorized {
+                        Button("HealthKit-Zugriff anfordern") {
+                            Task {
+                                try? await healthKitManager.requestAuthorization()
+                            }
+                        }
+                    }
+                }
+
+                // Statistics
+                Section("Statistiken") {
+                    StatRow(label: "Syncs heute", value: "\(syncCoordinator.todayStats.syncCount)")
+                    StatRow(label: "Konflikte heute", value: "\(syncCoordinator.todayStats.totalConflicts)")
+                    StatRow(label: "Automatisch gelöst", value: "\(syncCoordinator.todayStats.autoResolved)")
+                    StatRow(label: "Auflösungsrate", value: "\(Int(syncCoordinator.todayStats.resolutionRate * 100))%")
+                }
+
+                // Data Management
+                Section("Daten") {
+                    Button("Sync-Verlauf exportieren") {
+                        showingExportSheet = true
+                    }
+
+                    Button("Sync-Verlauf löschen", role: .destructive) {
+                        showingClearDataConfirmation = true
+                    }
+                }
+
+                // About
+                Section("Info") {
+                    HStack {
+                        Text("Version")
+                        Spacer()
+                        Text("1.0.0")
+                            .foregroundStyle(.secondary)
+                    }
+
+                    Link(destination: URL(string: "https://apple.com/health")!) {
+                        HStack {
+                            Text("Apple Health")
+                            Spacer()
+                            Image(systemName: "arrow.up.right.square")
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+                }
+            }
+            .navigationTitle("Einstellungen")
+            .confirmationDialog(
+                "Sync-Verlauf löschen?",
+                isPresented: $showingClearDataConfirmation,
+                titleVisibility: .visible
+            ) {
+                Button("Löschen", role: .destructive) {
+                    syncCoordinator.clearHistory()
+                }
+                Button("Abbrechen", role: .cancel) {}
+            } message: {
+                Text("Der gesamte Sync-Verlauf wird gelöscht. Dies kann nicht rückgängig gemacht werden.")
+            }
+            .sheet(isPresented: $showingExportSheet) {
+                ExportView()
+            }
+        }
+    }
+}
+
+// MARK: - Stat Row
+
+struct StatRow: View {
+    let label: String
+    let value: String
+
+    var body: some View {
+        HStack {
+            Text(label)
+            Spacer()
+            Text(value)
+                .foregroundStyle(.secondary)
+        }
+    }
+}
+
+// MARK: - Export View
+
+struct ExportView: View {
+    @Environment(\.dismiss) private var dismiss
+    @StateObject private var syncCoordinator = SyncCoordinator.shared
+
+    @State private var exportFormat: ExportFormat = .json
+    @State private var isExporting = false
+
+    enum ExportFormat: String, CaseIterable {
+        case json = "JSON"
+        case csv = "CSV"
+    }
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 20) {
+                Image(systemName: "square.and.arrow.up")
+                    .font(.system(size: 48))
+                    .foregroundStyle(.blue)
+
+                Text("Daten exportieren")
+                    .font(.title2)
+                    .fontWeight(.semibold)
+
+                Picker("Format", selection: $exportFormat) {
+                    ForEach(ExportFormat.allCases, id: \.self) { format in
+                        Text(format.rawValue).tag(format)
+                    }
+                }
+                .pickerStyle(.segmented)
+                .padding(.horizontal)
+
+                Text("\(syncCoordinator.syncHistory.count) Sync-Einträge")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+
+                Spacer()
+
+                Button {
+                    exportData()
+                } label: {
+                    Label("Exportieren", systemImage: "square.and.arrow.up")
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.borderedProminent)
+                .padding()
+                .disabled(isExporting || syncCoordinator.syncHistory.isEmpty)
+            }
+            .padding()
+            .navigationTitle("Export")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Abbrechen") {
+                        dismiss()
+                    }
+                }
+            }
+        }
+    }
+
+    private func exportData() {
+        isExporting = true
+
+        // In a real app, this would create and share a file
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
+            isExporting = false
+            dismiss()
+        }
+    }
+}
+
+#Preview {
+    SettingsView()
+}

HealthBridge/Views/SourcesView.swift

@@ -0,0 +1,407 @@
+import SwiftUI
+
+struct SourcesView: View {
+    @StateObject private var sourceManager = SourceManager.shared
+    @State private var selectedSource: HealthSource?
+    @State private var isRefreshing = false
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if sourceManager.sources.isEmpty && !sourceManager.isDiscovering {
+                    emptyState
+                } else {
+                    sourcesList
+                }
+            }
+            .navigationTitle("Quellen")
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button {
+                        Task { await refreshSources() }
+                    } label: {
+                        if isRefreshing {
+                            ProgressView()
+                                .scaleEffect(0.8)
+                        } else {
+                            Image(systemName: "arrow.clockwise")
+                        }
+                    }
+                    .disabled(isRefreshing)
+                }
+            }
+            .sheet(item: $selectedSource) { source in
+                SourceDetailView(source: source)
+            }
+            .task {
+                if sourceManager.sources.isEmpty {
+                    await refreshSources()
+                }
+            }
+        }
+    }
+
+    // MARK: - Empty State
+
+    private var emptyState: some View {
+        VStack(spacing: 16) {
+            Image(systemName: "antenna.radiowaves.left.and.right")
+                .font(.system(size: 64))
+                .foregroundStyle(.secondary)
+
+            Text("Keine Quellen gefunden")
+                .font(.title2)
+                .fontWeight(.semibold)
+
+            Text("Verbinden Sie Geräte mit Apple Health")
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+
+            Button {
+                Task { await refreshSources() }
+            } label: {
+                Label("Aktualisieren", systemImage: "arrow.clockwise")
+            }
+            .buttonStyle(.bordered)
+        }
+        .padding()
+    }
+
+    // MARK: - Sources List
+
+    private var sourcesList: some View {
+        List {
+            ForEach(groupedSources.keys.sorted(by: { $0.priority > $1.priority }), id: \.self) { category in
+                Section(category.displayName) {
+                    ForEach(groupedSources[category] ?? []) { source in
+                        SourceRow(source: source)
+                            .contentShape(Rectangle())
+                            .onTapGesture {
+                                selectedSource = source
+                            }
+                    }
+                }
+            }
+        }
+        .listStyle(.insetGrouped)
+        .refreshable {
+            await refreshSources()
+        }
+    }
+
+    private var groupedSources: [SourceCategory: [HealthSource]] {
+        Dictionary(grouping: sourceManager.sources, by: { $0.category })
+    }
+
+    private func refreshSources() async {
+        isRefreshing = true
+        defer { isRefreshing = false }
+        await sourceManager.discoverSources()
+    }
+}
+
+// MARK: - Source Row
+
+struct SourceRow: View {
+    let source: HealthSource
+    @StateObject private var sourceManager = SourceManager.shared
+
+    var body: some View {
+        HStack {
+            Image(systemName: source.category.icon)
+                .font(.title2)
+                .foregroundStyle(.blue)
+                .frame(width: 40)
+
+            VStack(alignment: .leading, spacing: 4) {
+                Text(source.displayName)
+                    .font(.headline)
+
+                Text("\(source.supportedDataTypes.count) Datentypen")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+
+            Spacer()
+
+            if let status = sourceManager.sourceHealthStatus[source.id] {
+                Image(systemName: status.syncStatus.icon)
+                    .foregroundStyle(statusColor(for: status.syncStatus))
+            }
+
+            Image(systemName: "chevron.right")
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+        .padding(.vertical, 4)
+    }
+
+    private func statusColor(for status: SourceHealthStatus.SyncStatus) -> Color {
+        switch status {
+        case .recentlySynced: return .green
+        case .syncedToday: return .blue
+        case .stale: return .orange
+        case .veryStale, .neverSynced: return .red
+        }
+    }
+}
+
+// MARK: - Source Detail View
+
+struct SourceDetailView: View {
+    let source: HealthSource
+    @Environment(\.dismiss) private var dismiss
+    @StateObject private var sourceManager = SourceManager.shared
+    @State private var healthReport: SourceHealthReport?
+    @State private var isLoading = false
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(spacing: 20) {
+                    // Header
+                    headerSection
+
+                    // Capabilities
+                    capabilitiesSection
+
+                    // Data Types
+                    dataTypesSection
+
+                    // Health Report
+                    if let report = healthReport {
+                        healthReportSection(report)
+                    }
+
+                    // Priority Settings
+                    prioritySection
+                }
+                .padding()
+            }
+            .navigationTitle(source.displayName)
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Fertig") {
+                        dismiss()
+                    }
+                }
+            }
+            .task {
+                await loadHealthReport()
+            }
+        }
+    }
+
+    // MARK: - Header
+
+    private var headerSection: some View {
+        VStack(spacing: 12) {
+            Image(systemName: source.category.icon)
+                .font(.system(size: 48))
+                .foregroundStyle(.blue)
+
+            Text(source.displayName)
+                .font(.title2)
+                .fontWeight(.semibold)
+
+            Text(source.category.displayName)
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+
+            Text(source.bundleIdentifier)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+                .textSelection(.enabled)
+        }
+        .padding()
+    }
+
+    // MARK: - Capabilities
+
+    private var capabilitiesSection: some View {
+        let capabilities = sourceManager.getSourceCapabilities(source)
+
+        return VStack(alignment: .leading, spacing: 12) {
+            Text("Fähigkeiten")
+                .font(.headline)
+
+            LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))], spacing: 8) {
+                CapabilityBadge(name: "Schritte", available: capabilities.canMeasureSteps)
+                CapabilityBadge(name: "Herzfrequenz", available: capabilities.canMeasureHeartRate)
+                CapabilityBadge(name: "Blutdruck", available: capabilities.canMeasureBloodPressure)
+                CapabilityBadge(name: "SpO2", available: capabilities.canMeasureBloodOxygen)
+                CapabilityBadge(name: "Schlaf", available: capabilities.canMeasureSleep)
+                CapabilityBadge(name: "GPS", available: capabilities.hasGPS)
+            }
+        }
+        .padding()
+        .background(Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+
+    // MARK: - Data Types
+
+    private var dataTypesSection: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Unterstützte Datentypen")
+                .font(.headline)
+
+            ForEach(Array(source.supportedDataTypes).sorted(by: { $0.displayName < $1.displayName }), id: \.self) { dataType in
+                HStack {
+                    Image(systemName: dataType.icon)
+                        .foregroundStyle(.blue)
+                        .frame(width: 24)
+                    Text(dataType.displayName)
+                    Spacer()
+                    Text(dataType.unit)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+                .padding(.vertical, 4)
+            }
+        }
+        .padding()
+        .background(Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+
+    // MARK: - Health Report
+
+    private func healthReportSection(_ report: SourceHealthReport) -> some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Zustand")
+                .font(.headline)
+
+            HStack {
+                VStack(alignment: .leading) {
+                    Text("Datensätze (24h)")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Text("\(report.totalRecordCount)")
+                        .font(.title3)
+                        .fontWeight(.medium)
+                }
+
+                Spacer()
+
+                VStack(alignment: .trailing) {
+                    Text("Qualität")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Image(systemName: report.overallQuality.icon)
+                        .font(.title3)
+                        .foregroundStyle(qualityColor(report.overallQuality))
+                }
+            }
+
+            if let lastActivity = report.lastOverallActivity {
+                HStack {
+                    Text("Letzte Aktivität")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Spacer()
+                    Text(formattedDate(lastActivity))
+                        .font(.subheadline)
+                }
+            }
+
+            if report.hasSignificantGaps {
+                HStack {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .foregroundStyle(.orange)
+                    Text("Datenlücken erkannt")
+                        .font(.subheadline)
+                }
+            }
+        }
+        .padding()
+        .background(Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+
+    // MARK: - Priority Section
+
+    private var prioritySection: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Text("Priorität")
+                .font(.headline)
+
+            Text("Höhere Priorität bedeutet, dass Daten dieser Quelle bevorzugt werden")
+                .font(.caption)
+                .foregroundStyle(.secondary)
+
+            ForEach(Array(source.supportedDataTypes).sorted(by: { $0.displayName < $1.displayName }), id: \.self) { dataType in
+                HStack {
+                    Text(dataType.displayName)
+
+                    Spacer()
+
+                    Stepper(
+                        "\(sourceManager.getPriority(for: source, dataType: dataType))",
+                        value: Binding(
+                            get: { sourceManager.getPriority(for: source, dataType: dataType) },
+                            set: { sourceManager.setPriority($0, for: source, dataType: dataType) }
+                        ),
+                        in: 0...100,
+                        step: 10
+                    )
+                    .frame(width: 150)
+                }
+                .padding(.vertical, 4)
+            }
+        }
+        .padding()
+        .background(Color(.secondarySystemBackground))
+        .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+
+    // MARK: - Helpers
+
+    private func loadHealthReport() async {
+        isLoading = true
+        defer { isLoading = false }
+        healthReport = await sourceManager.getSourceHealth(source)
+    }
+
+    private func qualityColor(_ quality: DataQuality) -> Color {
+        switch quality {
+        case .complete: return .green
+        case .partial: return .yellow
+        case .missing: return .gray
+        case .invalid: return .red
+        }
+    }
+
+    private func formattedDate(_ date: Date) -> String {
+        let formatter = RelativeDateTimeFormatter()
+        formatter.unitsStyle = .abbreviated
+        return formatter.localizedString(for: date, relativeTo: Date())
+    }
+}
+
+// MARK: - Capability Badge
+
+struct CapabilityBadge: View {
+    let name: String
+    let available: Bool
+
+    var body: some View {
+        HStack(spacing: 4) {
+            Image(systemName: available ? "checkmark.circle.fill" : "xmark.circle")
+                .foregroundStyle(available ? .green : .secondary)
+            Text(name)
+                .font(.caption)
+                .foregroundStyle(available ? .primary : .secondary)
+        }
+        .padding(.horizontal, 8)
+        .padding(.vertical, 4)
+        .background(available ? Color.green.opacity(0.1) : Color.gray.opacity(0.1))
+        .clipShape(Capsule())
+    }
+}
+
+#Preview {
+    SourcesView()
+}

RollkofferSimulator/AppDelegate.swift

@@ -14,6 +14,10 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
     func application(_ application: UIApplication,
                      didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        #if targetEnvironment(macCatalyst)
+        // Configure for macOS
+        configureMacOS()
+        #endif
         return true
     }
 
@@ -33,10 +37,60 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
     func applicationDidBecomeActive(_ application: UIApplication) {
         // Resume game if needed
     }
+
+    #if targetEnvironment(macCatalyst)
+    // MARK: - macOS Configuration
+    private func configureMacOS() {
+        // Set minimum window size for macOS
+        UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.forEach { windowScene in
+            windowScene.sizeRestrictions?.minimumSize = CGSize(width: 400, height: 600)
+            windowScene.sizeRestrictions?.maximumSize = CGSize(width: 600, height: 900)
+        }
+    }
+
+    override func buildMenu(with builder: UIMenuBuilder) {
+        super.buildMenu(with: builder)
+
+        // Remove unnecessary menus for a game
+        builder.remove(menu: .format)
+        builder.remove(menu: .edit)
+
+        // Add Game menu
+        let pauseCommand = UIKeyCommand(
+            title: "Pause",
+            action: #selector(handlePauseCommand),
+            input: "p",
+            modifierFlags: .command
+        )
+
+        let restartCommand = UIKeyCommand(
+            title: "Neustart",
+            action: #selector(handleRestartCommand),
+            input: "r",
+            modifierFlags: .command
+        )
+
+        let gameMenu = UIMenu(
+            title: "Spiel",
+            children: [pauseCommand, restartCommand]
+        )
+
+        builder.insertSibling(gameMenu, afterMenu: .file)
+    }
+
+    @objc private func handlePauseCommand() {
+        NotificationCenter.default.post(name: .pauseGame, object: nil)
+    }
+
+    @objc private func handleRestartCommand() {
+        NotificationCenter.default.post(name: .restartGame, object: nil)
+    }
+    #endif
 }
 
 // MARK: - Notification Names
 extension Notification.Name {
     static let pauseGame = Notification.Name("pauseGame")
     static let resumeGame = Notification.Name("resumeGame")
+    static let restartGame = Notification.Name("restartGame")
 }

RollkofferSimulator/GameViewController.swift

@@ -36,6 +36,10 @@ class GameViewController: UIViewController {
 
         // Setup notification observers
         setupNotificationObservers()
+
+        #if targetEnvironment(macCatalyst)
+        setupMacCatalyst()
+        #endif
     }
 
     private func setupNotificationObservers() {
@@ -45,6 +49,13 @@ class GameViewController: UIViewController {
             name: .pauseGame,
             object: nil
         )
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleRestartNotification),
+            name: .restartGame,
+            object: nil
+        )
     }
 
     @objc private func handlePauseNotification() {
@@ -57,12 +68,46 @@ class GameViewController: UIViewController {
         // This is just a notification that the app is going to background
     }
 
+    @objc private func handleRestartNotification() {
+        guard let skView = self.view as? SKView else { return }
+
+        let menuScene = MenuScene(size: skView.bounds.size)
+        menuScene.scaleMode = .aspectFill
+
+        let transition = SKTransition.fade(withDuration: 0.5)
+        skView.presentScene(menuScene, transition: transition)
+    }
+
+    #if targetEnvironment(macCatalyst)
+    private func setupMacCatalyst() {
+        // Configure window appearance for macOS
+        if let windowScene = view.window?.windowScene {
+            windowScene.title = "Rollkoffer Simulator"
+
+            // Set window style
+            if let titlebar = windowScene.titlebar {
+                titlebar.titleVisibility = .visible
+                titlebar.toolbarStyle = .unified
+            }
+        }
+    }
+
+    // Enable keyboard input
+    override var canBecomeFirstResponder: Bool {
+        return true
+    }
+    #endif
+
     override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+        #if targetEnvironment(macCatalyst)
+        return .all
+        #else
         if UIDevice.current.userInterfaceIdiom == .phone {
             return .portrait
         } else {
             return .all
         }
+        #endif
     }
 
     override var prefersStatusBarHidden: Bool {

RollkofferSimulator/Info.plist

@@ -50,5 +50,9 @@
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 		<string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
+	<key>LSMinimumSystemVersion</key>
+	<string>13.0</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright 2024 Ingo K. All rights reserved.</string>
 </dict>
 </plist>

RollkofferSimulator/RollkofferSimulator.xcodeproj/project.pbxproj

@@ -381,6 +381,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 1;
+				DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = Info.plist;
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
@@ -393,9 +394,12 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
+				MACOSX_DEPLOYMENT_TARGET = 13.0;
 				MARKETING_VERSION = 1.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.ingok.RollkofferSimulator;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTS_MACCATALYST = YES;
+				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
@@ -409,6 +413,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 1;
+				DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = Info.plist;
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
@@ -421,9 +426,12 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
+				MACOSX_DEPLOYMENT_TARGET = 13.0;
 				MARKETING_VERSION = 1.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.ingok.RollkofferSimulator;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTS_MACCATALYST = YES;
+				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";

RollkofferSimulator/Scenes/GameOverScene.swift

@@ -223,6 +223,27 @@ class GameOverScene: SKScene {
         }
     }
 
+    // MARK: - Keyboard Handling (macOS)
+    #if targetEnvironment(macCatalyst)
+    override var canBecomeFirstResponder: Bool { true }
+
+    override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+        guard let key = presses.first?.key else {
+            super.pressesBegan(presses, with: event)
+            return
+        }
+
+        switch key.keyCode {
+        case .keyboardSpacebar, .keyboardReturnOrEnter:
+            retryGame()
+        case .keyboardEscape:
+            returnToMenu()
+        default:
+            super.pressesBegan(presses, with: event)
+        }
+    }
+    #endif
+
     private func retryGame() {
         let pressDown = SKAction.scale(to: 0.9, duration: 0.1)
         let pressUp = SKAction.scale(to: 1.0, duration: 0.1)

RollkofferSimulator/Scenes/GameScene.swift

@@ -318,6 +318,29 @@ class GameScene: SKScene {
         isDragging = false
     }
 
+    // MARK: - Keyboard Handling (macOS)
+    #if targetEnvironment(macCatalyst)
+    override var canBecomeFirstResponder: Bool { true }
+
+    override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+        guard let key = presses.first?.key else {
+            super.pressesBegan(presses, with: event)
+            return
+        }
+
+        switch key.keyCode {
+        case .keyboardEscape:
+            togglePause()
+        case .keyboardSpacebar:
+            if gameState.currentState == .paused {
+                resumeGame()
+            }
+        default:
+            super.pressesBegan(presses, with: event)
+        }
+    }
+    #endif
+
     // MARK: - Pause Handling
     private func togglePause() {
         if gameState.currentState == .playing {

RollkofferSimulator/Scenes/MenuScene.swift

@@ -245,6 +245,25 @@ class MenuScene: SKScene {
         }
     }
 
+    // MARK: - Keyboard Handling (macOS)
+    #if targetEnvironment(macCatalyst)
+    override var canBecomeFirstResponder: Bool { true }
+
+    override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+        guard let key = presses.first?.key else {
+            super.pressesBegan(presses, with: event)
+            return
+        }
+
+        switch key.keyCode {
+        case .keyboardSpacebar, .keyboardReturnOrEnter:
+            startGame()
+        default:
+            super.pressesBegan(presses, with: event)
+        }
+    }
+    #endif
+
     private func startGame() {
         // Button press effect
         let pressDown = SKAction.scale(to: 0.9, duration: 0.1)

RollkofferSimulator/Scenes/VictoryScene.swift

@@ -280,6 +280,27 @@ class VictoryScene: SKScene {
         }
     }
 
+    // MARK: - Keyboard Handling (macOS)
+    #if targetEnvironment(macCatalyst)
+    override var canBecomeFirstResponder: Bool { true }
+
+    override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+        guard let key = presses.first?.key else {
+            super.pressesBegan(presses, with: event)
+            return
+        }
+
+        switch key.keyCode {
+        case .keyboardSpacebar, .keyboardReturnOrEnter:
+            playAgain()
+        case .keyboardEscape:
+            returnToMenu()
+        default:
+            super.pressesBegan(presses, with: event)
+        }
+    }
+    #endif
+
     private func playAgain() {
         let pressDown = SKAction.scale(to: 0.9, duration: 0.1)
         let pressUp = SKAction.scale(to: 1.0, duration: 0.1)

aurora-livecam/.gitignore

@@ -0,0 +1,26 @@
+# Configuration (contains secrets)
+config.php
+
+# Cache files
+weather_cache.json
+active_viewers.json
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Vendor (if using composer)
+# vendor/
+
+# Uploads (user content)
+uploads/

aurora-livecam/INTEGRATION.md

@@ -0,0 +1,240 @@
+# Integration Guide für Aurora Livecam Erweiterungen
+
+## Übersicht der neuen Dateien
+
+```
+aurora-livecam/
+├── SettingsManager.php      # Admin-Einstellungen Klasse
+├── settings.json            # Einstellungen Datei
+├── js/
+│   ├── timelapse-controls.js   # Timelapse mit Slider
+│   ├── video-player.js         # Tagesvideos im Player
+│   └── admin-settings.js       # Admin AJAX
+├── css/
+│   └── player-controls.css     # Styles für Controls
+└── INTEGRATION.md           # Diese Anleitung
+```
+
+## Änderungen in index.php
+
+### 1. Am Anfang der Datei (nach den requires)
+
+```php
+<?php
+// ... bestehende requires ...
+
+// NEU: Settings Manager einbinden
+require_once 'SettingsManager.php';
+$settingsManager = new SettingsManager();
+
+// AJAX-Handler für Settings (VOR session_start!)
+$settingsManager->handleAjax();
+```
+
+### 2. Im HEAD-Bereich (CSS einbinden)
+
+```html
+<link rel="stylesheet" href="css/player-controls.css">
+```
+
+### 3. Vor </body> (JavaScript einbinden)
+
+```html
+<script src="js/timelapse-controls.js"></script>
+<script src="js/video-player.js"></script>
+<?php if ($adminManager->isAdmin()): ?>
+<script src="js/admin-settings.js"></script>
+<?php endif; ?>
+```
+
+### 4. Video-Container anpassen
+
+Ersetze den bestehenden video-container:
+
+```html
+<div class="video-container">
+    <?php echo $webcamManager->displayWebcam(); ?>
+
+    <!-- Timelapse Overlay -->
+    <div id="timelapse-viewer" style="display: none;">
+        <img id="timelapse-image" src="" alt="Timelapse">
+    </div>
+
+    <!-- NEU: Daily Video Player (wird dynamisch befüllt) -->
+</div>
+
+<!-- NEU: Timelapse Controls (außerhalb des Containers) -->
+<div id="timelapse-controls"></div>
+```
+
+### 5. Zuschauer-Anzeige konditionell machen
+
+Ersetze die Viewer-Stat Anzeige:
+
+```php
+<?php
+$viewerCount = $viewerCounter->getInitialCount();
+$showViewers = $settingsManager->shouldShowViewers($viewerCount);
+?>
+
+<?php if ($showViewers): ?>
+<div class="info-badge viewer-stat">
+    <span class="live-dot"></span>
+    <strong id="viewer-count-display"><?php echo $viewerCount; ?></strong>
+    <span>Zuschauer</span>
+</div>
+<?php endif; ?>
+```
+
+### 6. Kalender Links anpassen
+
+In der `VisualCalendarManager::displayVisualCalendar()` Methode:
+
+```php
+// Für Tagesvideos
+$playInPlayer = $settingsManager->shouldPlayInPlayer();
+$allowDownload = $settingsManager->shouldAllowDownload();
+
+if ($playInPlayer) {
+    // Im Player abspielen
+    $output .= '<a href="#" onclick="DailyVideoPlayer.playVideo(\'' . $video['path'] . '\', ' . ($allowDownload ? 'true' : 'false') . '); return false;" class="play-link">';
+    $output .= '▶️ Abspielen';
+    $output .= '</a>';
+}
+
+if ($allowDownload) {
+    // Download Link
+    $output .= '<a href="?download_specific_video=..." class="download-link">⬇️ Download</a>';
+}
+```
+
+### 7. Admin-Panel erweitern
+
+Füge im Admin-Bereich hinzu:
+
+```php
+<?php if ($adminManager->isAdmin()): ?>
+<section id="admin" class="section">
+    <div class="container">
+        <h2>Admin-Bereich</h2>
+
+        <!-- NEU: Settings Panel -->
+        <div id="admin-settings-panel">
+            <h3>⚙️ Anzeige-Einstellungen</h3>
+
+            <div class="settings-group">
+                <h4>👥 Zuschauer-Anzeige</h4>
+
+                <div class="setting-row">
+                    <span class="setting-label">Zuschauer-Anzahl anzeigen</span>
+                    <div class="setting-input">
+                        <label class="toggle-switch">
+                            <input type="checkbox" id="setting-viewer-enabled"
+                                   <?php echo $settingsManager->get('viewer_display.enabled') ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </label>
+                    </div>
+                </div>
+
+                <div class="setting-row">
+                    <span class="setting-label">Mindestanzahl für Anzeige</span>
+                    <div class="setting-input">
+                        <input type="number" id="setting-min-viewers" class="number-input"
+                               min="1" max="100"
+                               value="<?php echo $settingsManager->get('viewer_display.min_viewers'); ?>">
+                    </div>
+                </div>
+            </div>
+
+            <div class="settings-group">
+                <h4>🎬 Video-Modus</h4>
+
+                <div class="setting-row">
+                    <span class="setting-label">Videos im Player abspielen</span>
+                    <div class="setting-input">
+                        <label class="toggle-switch">
+                            <input type="checkbox" id="setting-play-in-player"
+                                   <?php echo $settingsManager->get('video_mode.play_in_player') ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </label>
+                    </div>
+                </div>
+
+                <div class="setting-row">
+                    <span class="setting-label">Download erlauben</span>
+                    <div class="setting-input">
+                        <label class="toggle-switch">
+                            <input type="checkbox" id="setting-allow-download"
+                                   <?php echo $settingsManager->get('video_mode.allow_download') ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </label>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Bestehender Admin-Content -->
+        <?php echo $adminManager->displayAdminContent(); ?>
+    </div>
+</section>
+<?php endif; ?>
+```
+
+### 8. Timelapse Button Event anpassen
+
+Im bestehenden JavaScript:
+
+```javascript
+timelapseButton.addEventListener('click', function(e) {
+    e.preventDefault();
+
+    if (timelapseViewer.style.display === 'none') {
+        // NEU: TimelapseController verwenden
+        TimelapseController.init(imageFiles);
+        TimelapseController.show();
+        timelapseButton.textContent = 'Zurück zur Live-Webcam';
+    } else {
+        TimelapseController.backToLive();
+    }
+});
+```
+
+### 9. Viewer Heartbeat anpassen
+
+Im JavaScript für den Viewer-Counter:
+
+```javascript
+function updateViewerCount() {
+    fetch(window.location.href, {
+        method: 'POST',
+        body: new URLSearchParams({action: 'viewer_heartbeat'})
+    })
+    .then(r => r.json())
+    .then(data => {
+        const display = document.getElementById('viewer-count-display');
+        const container = document.querySelector('.viewer-stat');
+
+        if (data.count && display) {
+            display.textContent = data.count;
+
+            // Mindestanzahl prüfen (aus Settings)
+            const minViewers = window.minViewersToShow || 1;
+            if (container) {
+                container.style.display = data.count >= minViewers ? 'inline-flex' : 'none';
+            }
+        }
+    });
+}
+```
+
+## Fertig!
+
+Nach diesen Änderungen hast du:
+- ✅ Timelapse mit Slider und 1x/10x/100x Geschwindigkeit
+- ✅ Rückwärts-Spulen im Timelapse
+- ✅ Tagesvideos im Player abspielen statt nur Download
+- ✅ "Zurück zu Live" Button
+- ✅ Admin-Einstellungen für Zuschauer-Anzeige
+- ✅ Mindestanzahl für Zuschauer-Anzeige
+- ✅ Video-Modus wählbar (Player/Download)
+- ✅ Alles ohne Seiten-Reload

aurora-livecam/SettingsManager.php

@@ -0,0 +1,396 @@
+<?php
+/**
+ * SettingsManager - Verwaltet Admin-Einstellungen
+ * Speichert in settings.json, lädt ohne Reload
+ */
+class SettingsManager {
+    private $settingsFile;
+    private $settings = [];
+
+    public function __construct($file = null) {
+        $this->settingsFile = $file ?: (__DIR__ . '/settings.json');
+        $this->load();
+    }
+
+    private function load() {
+        if (file_exists($this->settingsFile)) {
+            $content = file_get_contents($this->settingsFile);
+            $this->settings = json_decode($content, true) ?? $this->getDefaults();
+        } else {
+            $this->settings = $this->getDefaults();
+            $this->save();
+        }
+    }
+
+    private function getDefaults() {
+        return [
+            'viewer_display' => [
+                'enabled' => true,
+                'min_viewers' => 1,
+                'update_interval' => 5 // Sekunden
+            ],
+            'video_mode' => [
+                'play_in_player' => true,
+                'allow_download' => true
+            ],
+            'timelapse' => [
+                'default_speed' => 1,
+                'available_speeds' => [1, 10, 100]
+            ],
+            // Punkt 2: UI-Anzeige Features
+            'ui_display' => [
+                'show_recommendation_banner' => true,
+                'show_qr_code' => true,
+                'show_social_media' => true,
+                'show_patrouille_suisse' => true
+            ],
+            // Punkt 3: Zoom & Timelapse
+            'zoom_timelapse' => [
+                'show_zoom_controls' => true,
+                'max_zoom_level' => 4.0,
+                'timelapse_reverse_enabled' => true,
+                'weekly_timelapse_enabled' => true // Wochenzeitraffer Button
+            ],
+            // Auto-Screenshot für Galerie
+            'auto_screenshot' => [
+                'enabled' => false,
+                'interval_minutes' => 10,
+                'max_images' => 144, // 24h bei 10min Intervall
+                'save_to_gallery' => true
+            ],
+            // Email-Sharing
+            'sharing' => [
+                'email_enabled' => false,
+                'share_link_expiry_hours' => 24
+            ],
+            // Punkt 5: Content Management
+            'content' => [
+                'guestbook_enabled' => true,
+                'gallery_enabled' => true,
+                'ai_events_enabled' => true,
+                'max_guestbook_entries' => 50
+            ],
+            // Punkt 6: Technische Settings
+            'technical' => [
+                'viewer_update_interval' => 5, // Sekunden
+                'session_timeout' => 30 // Sekunden
+            ],
+            // Punkt 7: Theme & Design
+            'theme' => [
+                'default_theme' => 'theme-legacy',
+                'show_theme_switcher' => false
+            ],
+            // Punkt 8: SEO & Meta
+            'seo' => [
+                'custom_title' => '',
+                'meta_description' => '',
+                'meta_keywords' => ''
+            ],
+            // Weather Widget
+            'weather' => [
+                'enabled' => true,
+                'api_key' => '',
+                'location' => 'Oberdürnten,CH',
+                'lat' => '47.2833',
+                'lon' => '8.7167',
+                'update_interval' => 5, // Minuten
+                'units' => 'metric' // metric (Celsius) oder imperial (Fahrenheit)
+            ],
+            // SaaS Features - alle aktivierbar/deaktivierbar
+            'saas_features' => [
+                // Multi-Tenant
+                'multi_tenant_enabled' => false, // Aktiviert DB-basierte Tenant-Verwaltung
+                'customer_management_enabled' => false,
+
+                // Onboarding
+                'self_registration_enabled' => false,
+                'email_verification_required' => true,
+                'trial_enabled' => true,
+                'trial_days' => 14,
+
+                // Billing
+                'billing_enabled' => false,
+                'stripe_enabled' => false,
+                'free_plan_available' => true,
+
+                // Dashboard
+                'tenant_dashboard_enabled' => false,
+                'analytics_enabled' => false,
+                'custom_domain_enabled' => false,
+                'custom_branding_enabled' => false,
+
+                // Landing
+                'landing_page_enabled' => false,
+                'demo_mode_enabled' => false,
+
+                // Limits (Default für Free-Plan)
+                'default_max_viewers' => 50,
+                'default_storage_mb' => 500,
+                'default_retention_days' => 7
+            ],
+            'last_updated' => null,
+            'updated_by' => null
+        ];
+    }
+
+    public function get($key = null) {
+        if ($key === null) return $this->settings;
+        $keys = explode('.', $key);
+        $value = $this->settings;
+        foreach ($keys as $k) {
+            if (!isset($value[$k])) return null;
+            $value = $value[$k];
+        }
+        return $value;
+    }
+
+    public function set($key, $value) {
+        $keys = explode('.', $key);
+        $ref = &$this->settings;
+        foreach ($keys as $i => $k) {
+            if ($i === count($keys) - 1) {
+                $ref[$k] = $value;
+            } else {
+                if (!isset($ref[$k])) $ref[$k] = [];
+                $ref = &$ref[$k];
+            }
+        }
+        $this->settings['last_updated'] = date('Y-m-d H:i:s');
+        return $this->save();
+    }
+
+    private function save() {
+        $payload = json_encode($this->settings, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
+        if ($payload === false) {
+            return false;
+        }
+
+        return file_put_contents($this->settingsFile, $payload, LOCK_EX) !== false;
+    }
+
+    // Für AJAX-Anfragen
+    public function handleAjax() {
+        if ($_SERVER['REQUEST_METHOD'] !== 'POST') return;
+        if (!isset($_POST['settings_action'])) return;
+
+        header('Content-Type: application/json');
+
+        switch ($_POST['settings_action']) {
+            case 'get':
+                echo json_encode(['success' => true, 'settings' => $this->settings]);
+                exit;
+
+            case 'update':
+                $key = $_POST['key'] ?? null;
+                $value = $_POST['value'] ?? null;
+
+                // Boolean-Werte konvertieren
+                if ($value === 'true') $value = true;
+                if ($value === 'false') $value = false;
+                if (is_numeric($value)) $value = intval($value);
+
+                if ($key && $this->set($key, $value)) {
+                    echo json_encode(['success' => true, 'message' => 'Einstellung gespeichert']);
+                } else {
+                    echo json_encode([
+                        'success' => false,
+                        'message' => 'Fehler beim Speichern. Bitte Dateirechte prüfen.'
+                    ]);
+                }
+                exit;
+        }
+    }
+
+    // Viewer-Anzeige prüfen
+    public function shouldShowViewers($currentCount) {
+        if (!$this->get('viewer_display.enabled')) return false;
+        return $currentCount >= $this->get('viewer_display.min_viewers');
+    }
+
+    // Video-Modus prüfen
+    public function shouldPlayInPlayer() {
+        return $this->get('video_mode.play_in_player') === true;
+    }
+
+    public function shouldAllowDownload() {
+        return $this->get('video_mode.allow_download') === true;
+    }
+
+    // UI Display Helper
+    public function shouldShowRecommendationBanner() {
+        return $this->get('ui_display.show_recommendation_banner') === true;
+    }
+
+    public function shouldShowQRCode() {
+        return $this->get('ui_display.show_qr_code') === true;
+    }
+
+    public function shouldShowSocialMedia() {
+        return $this->get('ui_display.show_social_media') === true;
+    }
+
+    public function shouldShowPatrouillesuisse() {
+        return $this->get('ui_display.show_patrouille_suisse') === true;
+    }
+
+    // Content Management Helper
+    public function isGuestbookEnabled() {
+        return $this->get('content.guestbook_enabled') === true;
+    }
+
+    public function isGalleryEnabled() {
+        return $this->get('content.gallery_enabled') === true;
+    }
+
+    public function isAIEventsEnabled() {
+        return $this->get('content.ai_events_enabled') === true;
+    }
+
+    public function getMaxGuestbookEntries() {
+        return $this->get('content.max_guestbook_entries') ?? 50;
+    }
+
+    // Theme Helper
+    public function getDefaultTheme() {
+        return $this->get('theme.default_theme') ?? 'theme-legacy';
+    }
+
+    public function shouldShowThemeSwitcher() {
+        return $this->get('theme.show_theme_switcher') === true;
+    }
+
+    // Technical Helper
+    public function getViewerUpdateInterval() {
+        return $this->get('technical.viewer_update_interval') ?? 5;
+    }
+
+    public function getSessionTimeout() {
+        return $this->get('technical.session_timeout') ?? 30;
+    }
+
+    // Zoom & Timelapse Helper
+    public function shouldShowZoomControls() {
+        return $this->get('zoom_timelapse.show_zoom_controls') === true;
+    }
+
+    public function getMaxZoomLevel() {
+        return $this->get('zoom_timelapse.max_zoom_level') ?? 4.0;
+    }
+
+    public function isTimelapseReverseEnabled() {
+        return $this->get('zoom_timelapse.timelapse_reverse_enabled') === true;
+    }
+
+    public function isWeeklyTimelapseEnabled() {
+        return $this->get('zoom_timelapse.weekly_timelapse_enabled') !== false;
+    }
+
+    // Auto-Screenshot Helper
+    public function isAutoScreenshotEnabled() {
+        return $this->get('auto_screenshot.enabled') === true;
+    }
+
+    public function getAutoScreenshotInterval() {
+        return $this->get('auto_screenshot.interval_minutes') ?? 10;
+    }
+
+    public function getAutoScreenshotMaxImages() {
+        return $this->get('auto_screenshot.max_images') ?? 144;
+    }
+
+    // Sharing Helper
+    public function isEmailSharingEnabled() {
+        return $this->get('sharing.email_enabled') === true;
+    }
+
+    public function getShareLinkExpiryHours() {
+        return $this->get('sharing.share_link_expiry_hours') ?? 24;
+    }
+
+    // SEO Helper
+    public function getCustomTitle() {
+        $title = $this->get('seo.custom_title');
+        return !empty($title) ? $title : null;
+    }
+
+    public function getMetaDescription() {
+        return $this->get('seo.meta_description') ?? '';
+    }
+
+    public function getMetaKeywords() {
+        return $this->get('seo.meta_keywords') ?? '';
+    }
+
+    // Weather Helper
+    public function isWeatherEnabled() {
+        return $this->get('weather.enabled') === true;
+    }
+
+    public function getWeatherApiKey() {
+        return $this->get('weather.api_key') ?? '';
+    }
+
+    public function getWeatherLocation() {
+        return $this->get('weather.location') ?? 'Oberdürnten,CH';
+    }
+
+    public function getWeatherCoords() {
+        return [
+            'lat' => $this->get('weather.lat') ?? '47.2833',
+            'lon' => $this->get('weather.lon') ?? '8.7167'
+        ];
+    }
+
+    public function getWeatherUpdateInterval() {
+        return $this->get('weather.update_interval') ?? 5;
+    }
+
+    public function getWeatherUnits() {
+        return $this->get('weather.units') ?? 'metric';
+    }
+
+    // SaaS Feature Helper
+    public function isMultiTenantEnabled() {
+        return $this->get('saas_features.multi_tenant_enabled') === true;
+    }
+
+    public function isSelfRegistrationEnabled() {
+        return $this->get('saas_features.self_registration_enabled') === true;
+    }
+
+    public function isBillingEnabled() {
+        return $this->get('saas_features.billing_enabled') === true;
+    }
+
+    public function isStripeEnabled() {
+        return $this->get('saas_features.stripe_enabled') === true;
+    }
+
+    public function isTenantDashboardEnabled() {
+        return $this->get('saas_features.tenant_dashboard_enabled') === true;
+    }
+
+    public function isAnalyticsEnabled() {
+        return $this->get('saas_features.analytics_enabled') === true;
+    }
+
+    public function isCustomDomainEnabled() {
+        return $this->get('saas_features.custom_domain_enabled') === true;
+    }
+
+    public function isCustomBrandingEnabled() {
+        return $this->get('saas_features.custom_branding_enabled') === true;
+    }
+
+    public function isLandingPageEnabled() {
+        return $this->get('saas_features.landing_page_enabled') === true;
+    }
+
+    public function getTrialDays() {
+        return $this->get('saas_features.trial_days') ?? 14;
+    }
+
+    public function getDefaultMaxViewers() {
+        return $this->get('saas_features.default_max_viewers') ?? 50;
+    }
+}

aurora-livecam/WeatherManager.php

@@ -0,0 +1,225 @@
+<?php
+/**
+ * WeatherManager - Holt und cached Wetterdaten von Open-Meteo (kostenlos!)
+ * Keine API Key nötig!
+ */
+class WeatherManager {
+    private $settingsManager;
+    private $cacheFile = 'weather_cache.json';
+    private $cacheTime = 300; // 5 Minuten in Sekunden
+
+    public function __construct($settingsManager) {
+        $this->settingsManager = $settingsManager;
+    }
+
+    /**
+     * Holt aktuelle Wetterdaten (cached)
+     */
+    public function getCurrentWeather() {
+        // Prüfe ob Weather aktiviert ist
+        if (!$this->settingsManager->isWeatherEnabled()) {
+            return null;
+        }
+
+        // Prüfe Cache
+        $cached = $this->getCache();
+        if ($cached !== null) {
+            return $cached;
+        }
+
+        // Hole frische Daten von API (Open-Meteo)
+        $coords = $this->settingsManager->getWeatherCoords();
+
+        // Open-Meteo API URL - komplett kostenlos, kein API Key!
+        $url = "https://api.open-meteo.com/v1/forecast?" . http_build_query([
+            'latitude' => $coords['lat'],
+            'longitude' => $coords['lon'],
+            'current' => 'temperature_2m,relative_humidity_2m,precipitation,weather_code,wind_speed_10m,wind_direction_10m,pressure_msl,cloud_cover',
+            'timezone' => 'Europe/Zurich'
+        ]);
+
+        $ch = curl_init();
+        curl_setopt($ch, CURLOPT_URL, $url);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
+
+        $response = curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        if ($httpCode !== 200 || !$response) {
+            return ['error' => 'API Fehler'];
+        }
+
+        $data = json_decode($response, true);
+        if (!$data || !isset($data['current'])) {
+            return ['error' => 'Ungültige API Antwort'];
+        }
+
+        $current = $data['current'];
+
+        // Formatiere Daten
+        $weather = [
+            'temp' => round($current['temperature_2m'], 1),
+            'feels_like' => round($current['temperature_2m'], 1), // Open-Meteo hat keine "feels like"
+            'humidity' => $current['relative_humidity_2m'],
+            'pressure' => round($current['pressure_msl'], 0),
+            'wind_speed' => round($current['wind_speed_10m'], 1), // Schon in km/h!
+            'wind_deg' => $current['wind_direction_10m'],
+            'wind_direction' => $this->getWindDirection($current['wind_direction_10m']),
+            'clouds' => $current['cloud_cover'] ?? 0,
+            'description' => $this->getWeatherDescription($current['weather_code']),
+            'icon' => $this->getWeatherIcon($current['weather_code']),
+            'rain_1h' => $current['precipitation'] ?? 0,
+            'snow_1h' => 0, // Open-Meteo gibt Niederschlag gesamt
+            'location' => $this->settingsManager->getWeatherLocation(),
+            'timestamp' => time()
+        ];
+
+        // Cache speichern
+        $this->saveCache($weather);
+
+        return $weather;
+    }
+
+    /**
+     * Wandelt WMO Weather Code in Beschreibung um
+     * https://open-meteo.com/en/docs
+     */
+    private function getWeatherDescription($code) {
+        $descriptions = [
+            0 => 'Klar',
+            1 => 'Überwiegend klar',
+            2 => 'Teilweise bewölkt',
+            3 => 'Bewölkt',
+            45 => 'Neblig',
+            48 => 'Nebel mit Reifablagerung',
+            51 => 'Leichter Nieselregen',
+            53 => 'Mäßiger Nieselregen',
+            55 => 'Dichter Nieselregen',
+            61 => 'Leichter Regen',
+            63 => 'Mäßiger Regen',
+            65 => 'Starker Regen',
+            71 => 'Leichter Schneefall',
+            73 => 'Mäßiger Schneefall',
+            75 => 'Starker Schneefall',
+            77 => 'Schneegraupeln',
+            80 => 'Leichte Regenschauer',
+            81 => 'Mäßige Regenschauer',
+            82 => 'Starke Regenschauer',
+            85 => 'Leichte Schneeschauer',
+            86 => 'Starke Schneeschauer',
+            95 => 'Gewitter',
+            96 => 'Gewitter mit leichtem Hagel',
+            99 => 'Gewitter mit starkem Hagel'
+        ];
+
+        return $descriptions[$code] ?? 'Unbekannt';
+    }
+
+    /**
+     * Wandelt WMO Weather Code in Icon-Code um (OpenWeatherMap kompatibel)
+     */
+    private function getWeatherIcon($code) {
+        if ($code == 0) return '01d'; // Klar
+        if ($code >= 1 && $code <= 2) return '02d'; // Teilweise bewölkt
+        if ($code == 3) return '04d'; // Bewölkt
+        if ($code >= 45 && $code <= 48) return '50d'; // Nebel
+        if ($code >= 51 && $code <= 55) return '09d'; // Nieselregen
+        if ($code >= 61 && $code <= 65) return '10d'; // Regen
+        if ($code >= 71 && $code <= 77) return '13d'; // Schnee
+        if ($code >= 80 && $code <= 82) return '09d'; // Regenschauer
+        if ($code >= 85 && $code <= 86) return '13d'; // Schneeschauer
+        if ($code >= 95 && $code <= 99) return '11d'; // Gewitter
+
+        return '01d'; // Default
+    }
+
+    /**
+     * Wandelt Windrichtung (Grad) in Kompassrichtung um
+     */
+    private function getWindDirection($deg) {
+        $directions = ['N', 'NNO', 'NO', 'ONO', 'O', 'OSO', 'SO', 'SSO', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
+        $index = round($deg / 22.5) % 16;
+        return $directions[$index];
+    }
+
+    /**
+     * Holt Daten aus Cache (wenn noch gültig)
+     */
+    private function getCache() {
+        if (!file_exists($this->cacheFile)) {
+            return null;
+        }
+
+        $content = file_get_contents($this->cacheFile);
+        $data = json_decode($content, true);
+
+        if (!$data || !isset($data['timestamp'])) {
+            return null;
+        }
+
+        // Fehler nicht aus Cache zurückgeben (z.B. alter "API Key fehlt" Error)
+        if (isset($data['error'])) {
+            @unlink($this->cacheFile); // Cache mit Fehler löschen
+            return null;
+        }
+
+        // Update-Intervall aus Settings holen (in Minuten)
+        $updateInterval = $this->settingsManager->getWeatherUpdateInterval() * 60; // Minuten -> Sekunden
+
+        // Prüfe ob Cache noch gültig
+        if (time() - $data['timestamp'] < $updateInterval) {
+            return $data;
+        }
+
+        return null;
+    }
+
+    /**
+     * Speichert Daten im Cache (nur wenn kein Fehler)
+     */
+    private function saveCache($data) {
+        // Fehler nicht cachen
+        if (isset($data['error'])) {
+            return;
+        }
+        $json = json_encode($data, JSON_PRETTY_PRINT);
+        file_put_contents($this->cacheFile, $json, LOCK_EX);
+    }
+
+    /**
+     * Gibt Wetter-Icon-Emoji zurück
+     */
+    public function getWeatherEmoji($iconCode) {
+        $map = [
+            '01d' => '☀️', '01n' => '🌙',
+            '02d' => '⛅', '02n' => '☁️',
+            '03d' => '☁️', '03n' => '☁️',
+            '04d' => '☁️', '04n' => '☁️',
+            '09d' => '🌧️', '09n' => '🌧️',
+            '10d' => '🌦️', '10n' => '🌧️',
+            '11d' => '⛈️', '11n' => '⛈️',
+            '13d' => '❄️', '13n' => '❄️',
+            '50d' => '🌫️', '50n' => '🌫️'
+        ];
+        return $map[$iconCode] ?? '🌤️';
+    }
+
+    /**
+     * AJAX Handler für Wetter-Updates
+     */
+    public function handleAjax() {
+        if ($_SERVER['REQUEST_METHOD'] !== 'GET') return;
+        if (!isset($_GET['weather_action'])) return;
+
+        header('Content-Type: application/json');
+
+        if ($_GET['weather_action'] === 'get') {
+            $weather = $this->getCurrentWeather();
+            echo json_encode(['success' => true, 'data' => $weather]);
+            exit;
+        }
+    }
+}

aurora-livecam/api/auto-screenshot.php

@@ -0,0 +1,104 @@
+<?php
+/**
+ * Auto-Screenshot API
+ *
+ * Kann als Cron-Job aufgerufen werden:
+ * Beispiel: 0,10,20,30,40,50 * * * * curl -s http://localhost/api/auto-screenshot.php?key=YOUR_SECRET_KEY
+ *
+ * Oder via Webhook/Timer
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+header('Content-Type: application/json');
+
+$settingsManager = new SettingsManager();
+
+// Prüfe ob Feature aktiviert
+if (!$settingsManager->isAutoScreenshotEnabled()) {
+    echo json_encode(['success' => false, 'error' => 'Auto-Screenshot deaktiviert']);
+    exit;
+}
+
+// Optionale API-Key Validierung
+$configFile = dirname(__DIR__) . '/config.php';
+if (file_exists($configFile)) {
+    $config = require $configFile;
+    $apiKey = $config['auto_screenshot_key'] ?? '';
+
+    if (!empty($apiKey) && ($_GET['key'] ?? '') !== $apiKey) {
+        http_response_code(403);
+        echo json_encode(['success' => false, 'error' => 'Ungültiger API-Key']);
+        exit;
+    }
+}
+
+// Galerie-Verzeichnis erstellen
+$galleryDir = dirname(__DIR__) . '/gallery/auto/';
+if (!is_dir($galleryDir)) {
+    mkdir($galleryDir, 0755, true);
+}
+
+// Screenshot-Dateiname
+$filename = 'auto_' . date('Y-m-d_H-i-s') . '.jpg';
+$filepath = $galleryDir . $filename;
+
+// Video-Stream URL
+$streamUrl = 'test_video.m3u8';
+$logoPath = dirname(__DIR__) . '/logo.png';
+
+// FFmpeg-Befehl zum Erstellen des Screenshots
+$command = sprintf(
+    'ffmpeg -i %s -vframes 1 -q:v 2 %s 2>&1',
+    escapeshellarg($streamUrl),
+    escapeshellarg($filepath)
+);
+
+exec($command, $output, $returnVar);
+
+if ($returnVar !== 0 || !file_exists($filepath)) {
+    echo json_encode([
+        'success' => false,
+        'error' => 'Screenshot fehlgeschlagen',
+        'command' => $command,
+        'output' => implode("\n", $output)
+    ]);
+    exit;
+}
+
+// Alte Screenshots aufräumen (max. Anzahl einhalten)
+$maxImages = $settingsManager->getAutoScreenshotMaxImages();
+$existingFiles = glob($galleryDir . 'auto_*.jpg');
+rsort($existingFiles); // Neueste zuerst
+
+if (count($existingFiles) > $maxImages) {
+    $filesToDelete = array_slice($existingFiles, $maxImages);
+    foreach ($filesToDelete as $file) {
+        @unlink($file);
+    }
+}
+
+// Metadaten speichern
+$metaFile = $galleryDir . 'metadata.json';
+$metadata = [];
+if (file_exists($metaFile)) {
+    $metadata = json_decode(file_get_contents($metaFile), true) ?? [];
+}
+
+$metadata[$filename] = [
+    'created_at' => date('Y-m-d H:i:s'),
+    'timestamp' => time(),
+    'size' => filesize($filepath)
+];
+
+// Nur die letzten maxImages behalten
+$metadata = array_slice($metadata, -$maxImages, null, true);
+file_put_contents($metaFile, json_encode($metadata, JSON_PRETTY_PRINT));
+
+echo json_encode([
+    'success' => true,
+    'file' => $filename,
+    'path' => '/gallery/auto/' . $filename,
+    'total_images' => count(glob($galleryDir . 'auto_*.jpg'))
+]);

aurora-livecam/api/gallery.php

@@ -0,0 +1,97 @@
+<?php
+/**
+ * Gallery API
+ *
+ * GET /api/gallery.php - Liste alle Galerie-Bilder
+ * GET /api/gallery.php?date=2024-01-30 - Bilder eines bestimmten Datums
+ * GET /api/gallery.php?from=2024-01-01&to=2024-01-31 - Bilder in einem Zeitraum
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+header('Content-Type: application/json');
+header('Access-Control-Allow-Origin: *');
+
+$settingsManager = new SettingsManager();
+
+$galleryDir = dirname(__DIR__) . '/gallery/auto/';
+
+// Prüfe ob Galerie existiert
+if (!is_dir($galleryDir)) {
+    echo json_encode(['success' => true, 'images' => [], 'total' => 0]);
+    exit;
+}
+
+// Parameter
+$date = $_GET['date'] ?? null;
+$from = $_GET['from'] ?? null;
+$to = $_GET['to'] ?? null;
+$limit = min(100, (int)($_GET['limit'] ?? 50));
+$offset = max(0, (int)($_GET['offset'] ?? 0));
+
+// Alle Bilder holen
+$allFiles = glob($galleryDir . 'auto_*.jpg');
+rsort($allFiles); // Neueste zuerst
+
+$images = [];
+
+foreach ($allFiles as $file) {
+    $filename = basename($file);
+    // Extrahiere Datum aus Dateinamen: auto_2024-01-30_14-30-00.jpg
+    if (preg_match('/auto_(\d{4}-\d{2}-\d{2})_(\d{2}-\d{2}-\d{2})\.jpg/', $filename, $matches)) {
+        $fileDate = $matches[1];
+        $fileTime = str_replace('-', ':', $matches[2]);
+
+        // Datumsfilter
+        if ($date !== null && $fileDate !== $date) {
+            continue;
+        }
+
+        if ($from !== null && $fileDate < $from) {
+            continue;
+        }
+
+        if ($to !== null && $fileDate > $to) {
+            continue;
+        }
+
+        $images[] = [
+            'filename' => $filename,
+            'path' => '/gallery/auto/' . $filename,
+            'date' => $fileDate,
+            'time' => $fileTime,
+            'datetime' => $fileDate . ' ' . $fileTime,
+            'timestamp' => strtotime($fileDate . ' ' . $fileTime),
+            'size' => filesize($file)
+        ];
+    }
+}
+
+$total = count($images);
+
+// Pagination
+$images = array_slice($images, $offset, $limit);
+
+// Verfügbare Daten (für Kalender/Filter)
+$availableDates = [];
+foreach (glob($galleryDir . 'auto_*.jpg') as $file) {
+    if (preg_match('/auto_(\d{4}-\d{2}-\d{2})/', basename($file), $m)) {
+        $availableDates[$m[1]] = ($availableDates[$m[1]] ?? 0) + 1;
+    }
+}
+krsort($availableDates);
+
+echo json_encode([
+    'success' => true,
+    'images' => $images,
+    'total' => $total,
+    'offset' => $offset,
+    'limit' => $limit,
+    'available_dates' => $availableDates,
+    'filters' => [
+        'date' => $date,
+        'from' => $from,
+        'to' => $to
+    ]
+]);

aurora-livecam/api/share.php

@@ -0,0 +1,315 @@
+<?php
+/**
+ * Share API - Teilen von Bildern/Videos per E-Mail
+ *
+ * POST /api/share.php
+ * Body: { email: "friend@example.com", type: "video|image", path: "/videos/...", message: "Schau dir das an!" }
+ */
+
+use PHPMailer\PHPMailer\PHPMailer;
+use PHPMailer\PHPMailer\Exception;
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+header('Content-Type: application/json');
+header('Access-Control-Allow-Origin: *');
+header('Access-Control-Allow-Methods: POST, GET, OPTIONS');
+header('Access-Control-Allow-Headers: Content-Type');
+
+if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
+    http_response_code(200);
+    exit;
+}
+
+$settingsManager = new SettingsManager();
+
+// Prüfe ob Feature aktiviert
+if (!$settingsManager->isEmailSharingEnabled()) {
+    echo json_encode(['success' => false, 'error' => 'E-Mail-Sharing ist deaktiviert']);
+    exit;
+}
+
+// Config laden
+$configFile = dirname(__DIR__) . '/config.php';
+$config = file_exists($configFile) ? require $configFile : [];
+$mailConfig = $config['mail'] ?? [];
+
+if (empty($mailConfig['host']) || empty($mailConfig['username'])) {
+    echo json_encode(['success' => false, 'error' => 'E-Mail-Server nicht konfiguriert']);
+    exit;
+}
+
+// === GET: Share-Link generieren ===
+if ($_SERVER['REQUEST_METHOD'] === 'GET' && isset($_GET['generate'])) {
+    $path = $_GET['path'] ?? '';
+    $type = $_GET['type'] ?? 'video';
+
+    if (empty($path)) {
+        echo json_encode(['success' => false, 'error' => 'Kein Pfad angegeben']);
+        exit;
+    }
+
+    // Token generieren
+    $expiryHours = $settingsManager->getShareLinkExpiryHours();
+    $expiry = time() + ($expiryHours * 3600);
+    $token = hash_hmac('sha256', $path . $expiry, session_id() . 'share_secret');
+
+    // Share-Link speichern
+    $shareDir = dirname(__DIR__) . '/data/shares/';
+    if (!is_dir($shareDir)) {
+        mkdir($shareDir, 0755, true);
+    }
+
+    $shareId = bin2hex(random_bytes(16));
+    $shareData = [
+        'id' => $shareId,
+        'path' => $path,
+        'type' => $type,
+        'token' => $token,
+        'expiry' => $expiry,
+        'created_at' => date('Y-m-d H:i:s')
+    ];
+
+    file_put_contents($shareDir . $shareId . '.json', json_encode($shareData));
+
+    // URL generieren
+    $baseUrl = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http')
+        . '://' . $_SERVER['HTTP_HOST'];
+    $shareUrl = $baseUrl . '/api/share.php?view=' . $shareId;
+
+    echo json_encode([
+        'success' => true,
+        'share_url' => $shareUrl,
+        'share_id' => $shareId,
+        'expires_at' => date('Y-m-d H:i:s', $expiry)
+    ]);
+    exit;
+}
+
+// === GET: Share-Link anzeigen ===
+if ($_SERVER['REQUEST_METHOD'] === 'GET' && isset($_GET['view'])) {
+    $shareId = preg_replace('/[^a-f0-9]/', '', $_GET['view']);
+    $shareFile = dirname(__DIR__) . '/data/shares/' . $shareId . '.json';
+
+    if (!file_exists($shareFile)) {
+        header('Content-Type: text/html; charset=utf-8');
+        echo '<!DOCTYPE html><html><head><title>Link ungültig</title></head><body style="font-family:sans-serif;text-align:center;padding:50px;"><h1>❌ Link nicht gefunden</h1><p>Dieser Share-Link existiert nicht oder wurde bereits gelöscht.</p></body></html>';
+        exit;
+    }
+
+    $shareData = json_decode(file_get_contents($shareFile), true);
+
+    // Ablauf prüfen
+    if (time() > $shareData['expiry']) {
+        @unlink($shareFile);
+        header('Content-Type: text/html; charset=utf-8');
+        echo '<!DOCTYPE html><html><head><title>Link abgelaufen</title></head><body style="font-family:sans-serif;text-align:center;padding:50px;"><h1>⏰ Link abgelaufen</h1><p>Dieser Share-Link ist abgelaufen. Bitte fordere einen neuen Link an.</p></body></html>';
+        exit;
+    }
+
+    // Datei existiert?
+    $filePath = dirname(__DIR__) . $shareData['path'];
+    if (!file_exists($filePath)) {
+        header('Content-Type: text/html; charset=utf-8');
+        echo '<!DOCTYPE html><html><head><title>Datei nicht gefunden</title></head><body style="font-family:sans-serif;text-align:center;padding:50px;"><h1>📭 Datei nicht gefunden</h1><p>Die geteilte Datei existiert nicht mehr.</p></body></html>';
+        exit;
+    }
+
+    // Redirect zur Datei oder HTML-Seite mit eingebettetem Player
+    $isVideo = in_array(pathinfo($filePath, PATHINFO_EXTENSION), ['mp4', 'webm', 'mov']);
+    $isImage = in_array(pathinfo($filePath, PATHINFO_EXTENSION), ['jpg', 'jpeg', 'png', 'gif', 'webp']);
+
+    $siteName = $config['app']['name'] ?? 'Aurora Livecam';
+    $baseUrl = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http')
+        . '://' . $_SERVER['HTTP_HOST'];
+
+    header('Content-Type: text/html; charset=utf-8');
+    echo '<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Geteilte ' . ($isVideo ? 'Video' : 'Bild') . ' - ' . htmlspecialchars($siteName) . '</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+        .container {
+            background: white;
+            border-radius: 16px;
+            padding: 30px;
+            max-width: 900px;
+            width: 100%;
+            box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+        }
+        h1 { font-size: 1.5rem; margin-bottom: 20px; color: #333; }
+        video, img {
+            width: 100%;
+            max-height: 70vh;
+            object-fit: contain;
+            border-radius: 8px;
+            background: #000;
+        }
+        .download-btn {
+            display: inline-block;
+            margin-top: 20px;
+            padding: 12px 30px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            text-decoration: none;
+            border-radius: 8px;
+            font-weight: 600;
+        }
+        .download-btn:hover { opacity: 0.9; }
+        .footer {
+            margin-top: 20px;
+            color: rgba(255,255,255,0.8);
+            font-size: 0.9rem;
+        }
+        .footer a { color: white; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>📤 Geteilte' . ($isVideo ? 's Video' : 's Bild') . '</h1>';
+
+    if ($isVideo) {
+        echo '<video controls autoplay><source src="' . htmlspecialchars($shareData['path']) . '" type="video/mp4">Ihr Browser unterstützt kein Video.</video>';
+    } else {
+        echo '<img src="' . htmlspecialchars($shareData['path']) . '" alt="Geteiltes Bild">';
+    }
+
+    echo '
+        <a href="' . htmlspecialchars($shareData['path']) . '" download class="download-btn">⬇️ Herunterladen</a>
+    </div>
+    <div class="footer">
+        Geteilt von <a href="' . $baseUrl . '">' . htmlspecialchars($siteName) . '</a>
+    </div>
+</body>
+</html>';
+    exit;
+}
+
+// === POST: E-Mail senden ===
+if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
+    http_response_code(405);
+    echo json_encode(['success' => false, 'error' => 'Nur POST erlaubt']);
+    exit;
+}
+
+// JSON-Body parsen
+$input = json_decode(file_get_contents('php://input'), true);
+if (!$input) {
+    $input = $_POST;
+}
+
+$email = filter_var($input['email'] ?? '', FILTER_VALIDATE_EMAIL);
+$path = $input['path'] ?? '';
+$type = $input['type'] ?? 'video';
+$message = htmlspecialchars($input['message'] ?? '');
+$senderName = htmlspecialchars($input['sender_name'] ?? 'Ein Freund');
+
+if (!$email) {
+    echo json_encode(['success' => false, 'error' => 'Ungültige E-Mail-Adresse']);
+    exit;
+}
+
+if (empty($path)) {
+    echo json_encode(['success' => false, 'error' => 'Kein Pfad angegeben']);
+    exit;
+}
+
+// Share-Link generieren
+$expiryHours = $settingsManager->getShareLinkExpiryHours();
+$expiry = time() + ($expiryHours * 3600);
+
+$shareDir = dirname(__DIR__) . '/data/shares/';
+if (!is_dir($shareDir)) {
+    mkdir($shareDir, 0755, true);
+}
+
+$shareId = bin2hex(random_bytes(16));
+$shareData = [
+    'id' => $shareId,
+    'path' => $path,
+    'type' => $type,
+    'expiry' => $expiry,
+    'created_at' => date('Y-m-d H:i:s'),
+    'shared_to' => $email
+];
+
+file_put_contents($shareDir . $shareId . '.json', json_encode($shareData));
+
+$baseUrl = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http')
+    . '://' . $_SERVER['HTTP_HOST'];
+$shareUrl = $baseUrl . '/api/share.php?view=' . $shareId;
+$siteName = $config['app']['name'] ?? 'Aurora Livecam';
+
+// E-Mail senden
+try {
+    $mail = new PHPMailer(true);
+
+    // SMTP Konfiguration
+    $mail->isSMTP();
+    $mail->Host = $mailConfig['host'];
+    $mail->SMTPAuth = true;
+    $mail->Username = $mailConfig['username'];
+    $mail->Password = $mailConfig['password'];
+    $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
+    $mail->Port = $mailConfig['port'] ?? 587;
+    $mail->CharSet = 'UTF-8';
+
+    // Absender/Empfänger
+    $mail->setFrom($mailConfig['from_address'], $mailConfig['from_name'] ?? $siteName);
+    $mail->addAddress($email);
+
+    // Inhalt
+    $mail->isHTML(true);
+    $mail->Subject = $senderName . ' hat ' . ($type === 'video' ? 'ein Video' : 'ein Bild') . ' mit dir geteilt';
+
+    $mail->Body = '
+    <div style="font-family: -apple-system, BlinkMacSystemFont, \'Segoe UI\', Roboto, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
+        <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 30px; border-radius: 12px 12px 0 0; text-align: center;">
+            <h1 style="color: white; margin: 0; font-size: 24px;">📤 ' . htmlspecialchars($siteName) . '</h1>
+        </div>
+        <div style="background: #f7f7f7; padding: 30px; border-radius: 0 0 12px 12px;">
+            <p style="font-size: 18px; color: #333; margin-bottom: 20px;">
+                <strong>' . htmlspecialchars($senderName) . '</strong> hat ' . ($type === 'video' ? 'ein Video' : 'ein Bild') . ' mit dir geteilt!
+            </p>
+            ' . (!empty($message) ? '<div style="background: white; padding: 15px; border-radius: 8px; border-left: 4px solid #667eea; margin-bottom: 20px;"><em>"' . nl2br($message) . '"</em></div>' : '') . '
+            <a href="' . htmlspecialchars($shareUrl) . '" style="display: inline-block; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 15px 30px; text-decoration: none; border-radius: 8px; font-weight: 600; font-size: 16px;">
+                ▶️ Jetzt ansehen
+            </a>
+            <p style="margin-top: 20px; color: #888; font-size: 12px;">
+                Dieser Link ist ' . $expiryHours . ' Stunden gültig.
+            </p>
+        </div>
+    </div>';
+
+    $mail->AltBody = $senderName . ' hat ' . ($type === 'video' ? 'ein Video' : 'ein Bild') . ' mit dir geteilt: ' . $shareUrl;
+
+    $mail->send();
+
+    echo json_encode([
+        'success' => true,
+        'message' => 'E-Mail wurde gesendet',
+        'share_url' => $shareUrl
+    ]);
+
+} catch (Exception $e) {
+    error_log('Share email error: ' . $e->getMessage());
+    echo json_encode([
+        'success' => false,
+        'error' => 'E-Mail konnte nicht gesendet werden',
+        'share_url' => $shareUrl // URL trotzdem zurückgeben
+    ]);
+}

aurora-livecam/api/stripe-webhook.php

@@ -0,0 +1,56 @@
+<?php
+/**
+ * Stripe Webhook Endpoint
+ *
+ * URL: /api/stripe-webhook.php
+ * Konfigurieren Sie diesen Endpoint in Ihrem Stripe Dashboard
+ */
+
+// Keine Session, keine Ausgabe vor JSON
+error_reporting(0);
+ini_set('display_errors', 0);
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Billing\WebhookHandler;
+
+// Nur POST erlaubt
+if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
+    http_response_code(405);
+    echo json_encode(['error' => 'Method not allowed']);
+    exit;
+}
+
+// Payload lesen
+$payload = file_get_contents('php://input');
+$signature = $_SERVER['HTTP_STRIPE_SIGNATURE'] ?? '';
+
+if (empty($payload)) {
+    http_response_code(400);
+    echo json_encode(['error' => 'Empty payload']);
+    exit;
+}
+
+// Webhook verarbeiten
+try {
+    $handler = new WebhookHandler();
+    $result = $handler->handle($payload, $signature);
+
+    if ($result['success']) {
+        http_response_code(200);
+    } else {
+        http_response_code(400);
+    }
+
+    header('Content-Type: application/json');
+    echo json_encode($result);
+
+} catch (\Exception $e) {
+    error_log('Stripe Webhook Error: ' . $e->getMessage());
+    http_response_code(500);
+    echo json_encode(['error' => 'Internal server error']);
+}

aurora-livecam/api/video-search.php

@@ -0,0 +1,192 @@
+<?php
+/**
+ * Video Search API
+ *
+ * Suche nach Videos nach Datum und Uhrzeit
+ *
+ * GET /api/video-search.php?date=2024-01-30
+ * GET /api/video-search.php?date=2024-01-30&time=14:30
+ * GET /api/video-search.php?from=2024-01-01&to=2024-01-31
+ * GET /api/video-search.php?time_from=08:00&time_to=18:00
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+header('Content-Type: application/json');
+header('Access-Control-Allow-Origin: *');
+
+$settingsManager = new SettingsManager();
+
+$videoDir = dirname(__DIR__) . '/videos/';
+$aiDir = dirname(__DIR__) . '/ai/';
+
+// Parameter
+$date = $_GET['date'] ?? null; // Format: YYYY-MM-DD
+$time = $_GET['time'] ?? null; // Format: HH:MM
+$fromDate = $_GET['from'] ?? null;
+$toDate = $_GET['to'] ?? null;
+$timeFrom = $_GET['time_from'] ?? null;
+$timeTo = $_GET['time_to'] ?? null;
+$type = $_GET['type'] ?? 'all'; // all, daily, ai
+$aiCategory = $_GET['ai_category'] ?? null;
+$limit = min(100, (int)($_GET['limit'] ?? 50));
+
+$results = [
+    'daily_videos' => [],
+    'ai_videos' => [],
+    'gallery_images' => []
+];
+
+// AI-Kategorien
+$aiCategories = ['sunny', 'rainy', 'snowy', 'planes', 'birds', 'sunset', 'sunrise', 'rainbow'];
+
+// === TAGESVIDEOS SUCHEN ===
+if ($type === 'all' || $type === 'daily') {
+    $pattern = $videoDir . 'daily_video_*.mp4';
+    $dailyVideos = glob($pattern);
+
+    foreach ($dailyVideos as $video) {
+        $filename = basename($video);
+
+        // Extrahiere Datum aus Dateinamen: daily_video_YYYYMMDD_HHMMSS.mp4
+        if (preg_match('/daily_video_(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})\.mp4/', $filename, $matches)) {
+            $videoDate = $matches[1] . '-' . $matches[2] . '-' . $matches[3];
+            $videoTime = $matches[4] . ':' . $matches[5];
+            $videoDateTime = $videoDate . ' ' . $videoTime . ':' . $matches[6];
+
+            // Datumsfilter
+            if ($date !== null && $videoDate !== $date) {
+                continue;
+            }
+
+            if ($fromDate !== null && $videoDate < $fromDate) {
+                continue;
+            }
+
+            if ($toDate !== null && $videoDate > $toDate) {
+                continue;
+            }
+
+            // Uhrzeitfilter
+            if ($timeFrom !== null && $videoTime < $timeFrom) {
+                continue;
+            }
+
+            if ($timeTo !== null && $videoTime > $timeTo) {
+                continue;
+            }
+
+            // Spezifische Uhrzeit (mit 30 Min Toleranz)
+            if ($time !== null) {
+                $searchMinutes = intval(substr($time, 0, 2)) * 60 + intval(substr($time, 3, 2));
+                $videoMinutes = intval($matches[4]) * 60 + intval($matches[5]);
+
+                if (abs($searchMinutes - $videoMinutes) > 30) {
+                    continue;
+                }
+            }
+
+            $results['daily_videos'][] = [
+                'type' => 'daily',
+                'filename' => $filename,
+                'path' => '/videos/' . $filename,
+                'date' => $videoDate,
+                'time' => $videoTime,
+                'datetime' => $videoDateTime,
+                'timestamp' => strtotime($videoDateTime),
+                'size' => filesize($video),
+                'size_mb' => round(filesize($video) / (1024 * 1024), 2)
+            ];
+        }
+    }
+}
+
+// === AI-VIDEOS SUCHEN ===
+if ($type === 'all' || $type === 'ai') {
+    $searchCategories = $aiCategory ? [$aiCategory] : $aiCategories;
+
+    foreach ($searchCategories as $category) {
+        $categoryDir = $aiDir . $category . '/';
+        if (!is_dir($categoryDir)) continue;
+
+        $pattern = $categoryDir . $category . '_*.mp4';
+        $aiVideos = glob($pattern);
+
+        foreach ($aiVideos as $video) {
+            $filename = basename($video);
+
+            // Extrahiere Datum aus Dateinamen: category_YYYYMMDD_HHMMSS.mp4
+            if (preg_match('/' . $category . '_(\d{4})(\d{2})(\d{2})_?(\d{2})?(\d{2})?(\d{2})?\.mp4/', $filename, $matches)) {
+                $videoDate = $matches[1] . '-' . $matches[2] . '-' . $matches[3];
+                $videoTime = isset($matches[4]) ? ($matches[4] . ':' . ($matches[5] ?? '00')) : '00:00';
+                $videoDateTime = $videoDate . ' ' . $videoTime;
+
+                // Datumsfilter
+                if ($date !== null && $videoDate !== $date) {
+                    continue;
+                }
+
+                if ($fromDate !== null && $videoDate < $fromDate) {
+                    continue;
+                }
+
+                if ($toDate !== null && $videoDate > $toDate) {
+                    continue;
+                }
+
+                // Uhrzeitfilter
+                if ($timeFrom !== null && $videoTime < $timeFrom) {
+                    continue;
+                }
+
+                if ($timeTo !== null && $videoTime > $timeTo) {
+                    continue;
+                }
+
+                $results['ai_videos'][] = [
+                    'type' => 'ai',
+                    'category' => $category,
+                    'filename' => $filename,
+                    'path' => '/ai/' . $category . '/' . $filename,
+                    'date' => $videoDate,
+                    'time' => $videoTime,
+                    'datetime' => $videoDateTime,
+                    'timestamp' => strtotime($videoDateTime),
+                    'size' => filesize($video),
+                    'size_mb' => round(filesize($video) / (1024 * 1024), 2)
+                ];
+            }
+        }
+    }
+}
+
+// Sortieren nach Datum/Zeit (neueste zuerst)
+usort($results['daily_videos'], fn($a, $b) => $b['timestamp'] - $a['timestamp']);
+usort($results['ai_videos'], fn($a, $b) => $b['timestamp'] - $a['timestamp']);
+
+// Limit anwenden
+$results['daily_videos'] = array_slice($results['daily_videos'], 0, $limit);
+$results['ai_videos'] = array_slice($results['ai_videos'], 0, $limit);
+
+// Statistiken
+$results['stats'] = [
+    'total_daily' => count($results['daily_videos']),
+    'total_ai' => count($results['ai_videos']),
+    'total' => count($results['daily_videos']) + count($results['ai_videos'])
+];
+
+$results['filters'] = [
+    'date' => $date,
+    'time' => $time,
+    'from' => $fromDate,
+    'to' => $toDate,
+    'time_from' => $timeFrom,
+    'time_to' => $timeTo,
+    'type' => $type,
+    'ai_category' => $aiCategory
+];
+
+$results['success'] = true;
+
+echo json_encode($results, JSON_PRETTY_PRINT);

aurora-livecam/clear-cache.php

@@ -0,0 +1,15 @@
+<?php
+// Clear PHP OPcache
+if (function_exists('opcache_reset')) {
+    opcache_reset();
+    echo "OPcache cleared successfully!\n";
+} else {
+    echo "OPcache not available\n";
+}
+
+// Clear realpath cache
+clearstatcache(true);
+echo "Realpath cache cleared!\n";
+
+echo "\nNow reload the page with CTRL+F5 (hard refresh)\n";
+?>

aurora-livecam/config.example.php

@@ -0,0 +1,59 @@
+<?php
+/**
+ * Aurora Livecam - Konfigurationsdatei
+ *
+ * Kopiere diese Datei zu config.php und passe die Werte an.
+ * WICHTIG: config.php niemals in Git committen!
+ */
+
+return [
+    // Datenbank-Konfiguration
+    'database' => [
+        'host' => 'localhost',
+        'port' => 3306,
+        'database' => 'aurora_livecam',
+        'username' => 'root',
+        'password' => '',
+        'charset' => 'utf8mb4',
+    ],
+
+    // Anwendungs-Einstellungen
+    'app' => [
+        'name' => 'Aurora Livecam',
+        'url' => 'https://aurora-weather-livecam.com',
+        'debug' => false,
+        'timezone' => 'Europe/Zurich',
+    ],
+
+    // Multi-Tenant Einstellungen
+    'tenant' => [
+        'default_subdomain_suffix' => '.aurora-livecam.com',
+        'allow_custom_domains' => true,
+        'trial_days' => 14,
+    ],
+
+    // Stripe (für Billing)
+    'stripe' => [
+        'public_key' => '',
+        'secret_key' => '',
+        'webhook_secret' => '',
+        'currency' => 'chf',
+    ],
+
+    // E-Mail Einstellungen (für Onboarding)
+    'mail' => [
+        'host' => 'smtp.example.com',
+        'port' => 587,
+        'username' => '',
+        'password' => '',
+        'from_address' => 'noreply@aurora-livecam.com',
+        'from_name' => 'Aurora Livecam',
+    ],
+
+    // Sicherheit
+    'security' => [
+        'session_lifetime' => 7200, // 2 Stunden
+        'remember_me_days' => 30,
+        'password_min_length' => 8,
+    ],
+];

aurora-livecam/css/player-controls.css

@@ -0,0 +1,274 @@
+/* ========== TIMELAPSE CONTROLS ========== */
+#timelapse-controls {
+    display: none;
+    margin-top: 15px;
+}
+
+.timelapse-control-bar {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    background: rgba(255, 255, 255, 0.95);
+    padding: 12px 20px;
+    border-radius: 50px;
+    box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+    flex-wrap: wrap;
+    justify-content: center;
+}
+
+.tl-btn {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    width: 44px;
+    height: 44px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 16px;
+    transition: all 0.3s ease;
+    box-shadow: 0 2px 8px rgba(102, 126, 234, 0.3);
+}
+
+.tl-btn:hover {
+    transform: scale(1.1);
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.5);
+}
+
+.tl-btn.active {
+    background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%);
+}
+
+.tl-slider-container {
+    flex: 1;
+    min-width: 200px;
+    max-width: 400px;
+    display: flex;
+    align-items: center;
+    gap: 15px;
+}
+
+#tl-slider {
+    flex: 1;
+    height: 8px;
+    border-radius: 4px;
+    background: #e0e0e0;
+    outline: none;
+    -webkit-appearance: none;
+}
+
+#tl-slider::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    cursor: pointer;
+    box-shadow: 0 2px 6px rgba(0,0,0,0.2);
+}
+
+#tl-slider::-moz-range-thumb {
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    cursor: pointer;
+    border: none;
+}
+
+#tl-time-display {
+    font-family: monospace;
+    font-size: 14px;
+    color: #333;
+    background: #f5f5f5;
+    padding: 6px 12px;
+    border-radius: 20px;
+    min-width: 140px;
+    text-align: center;
+}
+
+.tl-speed-btn {
+    width: auto !important;
+    padding: 0 20px !important;
+    border-radius: 22px !important;
+    font-weight: bold;
+    font-size: 14px;
+}
+
+.tl-back-btn {
+    width: auto !important;
+    padding: 0 20px !important;
+    border-radius: 22px !important;
+    background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%) !important;
+    gap: 8px;
+}
+
+/* ========== DAILY VIDEO PLAYER ========== */
+#daily-video-player {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: #000;
+    z-index: 50;
+}
+
+#daily-video {
+    width: 100%;
+    height: 100%;
+    object-fit: contain;
+}
+
+.video-player-controls {
+    position: absolute;
+    bottom: 20px;
+    left: 50%;
+    transform: translateX(-50%);
+    display: flex;
+    gap: 15px;
+    z-index: 60;
+}
+
+/* ========== ADMIN SETTINGS PANEL ========== */
+#admin-settings-panel {
+    background: white;
+    padding: 25px;
+    border-radius: 12px;
+    margin-bottom: 30px;
+    box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+}
+
+#admin-settings-panel h3 {
+    color: #667eea;
+    border-bottom: 2px solid #667eea;
+    padding-bottom: 10px;
+    margin-bottom: 20px;
+}
+
+.settings-group {
+    margin-bottom: 25px;
+    padding: 20px;
+    background: #f9f9f9;
+    border-radius: 8px;
+}
+
+.settings-group h4 {
+    margin-bottom: 15px;
+    color: #333;
+}
+
+.setting-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 12px 0;
+    border-bottom: 1px solid #eee;
+}
+
+.setting-row:last-child {
+    border-bottom: none;
+}
+
+.setting-label {
+    font-weight: 500;
+    color: #555;
+}
+
+.setting-input {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+/* Toggle Switch */
+.toggle-switch {
+    position: relative;
+    width: 50px;
+    height: 26px;
+}
+
+.toggle-switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.toggle-slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: #ccc;
+    transition: 0.3s;
+    border-radius: 26px;
+}
+
+.toggle-slider:before {
+    position: absolute;
+    content: "";
+    height: 20px;
+    width: 20px;
+    left: 3px;
+    bottom: 3px;
+    background-color: white;
+    transition: 0.3s;
+    border-radius: 50%;
+}
+
+input:checked + .toggle-slider {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+}
+
+input:checked + .toggle-slider:before {
+    transform: translateX(24px);
+}
+
+/* Number Input */
+.number-input {
+    width: 70px;
+    padding: 8px;
+    border: 2px solid #ddd;
+    border-radius: 8px;
+    font-size: 16px;
+    text-align: center;
+}
+
+.number-input:focus {
+    border-color: #667eea;
+    outline: none;
+}
+
+/* ========== MOBILE RESPONSIVE ========== */
+@media (max-width: 600px) {
+    .timelapse-control-bar {
+        padding: 10px 15px;
+        gap: 8px;
+    }
+
+    .tl-btn {
+        width: 38px;
+        height: 38px;
+        font-size: 14px;
+    }
+
+    .tl-slider-container {
+        width: 100%;
+        order: 10;
+        margin-top: 10px;
+    }
+
+    #tl-time-display {
+        font-size: 12px;
+        min-width: 120px;
+    }
+
+    .video-player-controls {
+        flex-direction: column;
+        bottom: 10px;
+    }
+}

aurora-livecam/dashboard/api/stats.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * Dashboard API - Stats
+ */
+
+header('Content-Type: application/json');
+
+require_once dirname(__DIR__, 2) . '/vendor/autoload.php';
+require_once dirname(__DIR__, 2) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__, 2) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__, 2) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Core\Database;
+
+$auth = new AuthManager();
+
+// Auth check
+if (!$auth->isLoggedIn()) {
+    http_response_code(401);
+    echo json_encode(['success' => false, 'error' => 'Unauthorized']);
+    exit;
+}
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$stats = [
+    'viewers_current' => 0,
+    'viewers_today' => 0,
+    'viewers_peak' => 0,
+    'stream_status' => 'unknown',
+];
+
+// Aktuelle Zuschauer aus Datei
+$viewerFile = dirname(__DIR__, 2) . '/active_viewers.json';
+if (file_exists($viewerFile)) {
+    $viewers = json_decode(file_get_contents($viewerFile), true);
+    $stats['viewers_current'] = count($viewers ?? []);
+}
+
+// DB Stats falls verfügbar
+try {
+    $db = Database::getInstance();
+
+    if ($tenantId > 0) {
+        $todayStats = $db->fetchOne(
+            "SELECT SUM(viewer_count) as total, MAX(viewer_count) as peak
+             FROM viewer_stats
+             WHERE tenant_id = ? AND DATE(recorded_at) = CURDATE()",
+            [$tenantId]
+        );
+
+        if ($todayStats) {
+            $stats['viewers_today'] = (int)($todayStats['total'] ?? 0);
+            $stats['viewers_peak'] = (int)($todayStats['peak'] ?? 0);
+        }
+
+        $stream = $db->fetchOne(
+            "SELECT last_status FROM tenant_streams WHERE tenant_id = ? AND is_primary = 1",
+            [$tenantId]
+        );
+        $stats['stream_status'] = $stream['last_status'] ?? 'unknown';
+    }
+} catch (\Exception $e) {
+    // DB nicht verfügbar - Stats bleiben auf Defaults
+}
+
+echo json_encode([
+    'success' => true,
+    'stats' => $stats,
+    'timestamp' => time(),
+]);

aurora-livecam/dashboard/assets/dashboard.css

@@ -0,0 +1,536 @@
+/* Dashboard CSS */
+:root {
+    --primary: #667eea;
+    --primary-dark: #5a67d8;
+    --secondary: #764ba2;
+    --accent: #f093fb;
+    --success: #48bb78;
+    --warning: #ed8936;
+    --danger: #f56565;
+    --dark: #1a202c;
+    --gray-900: #1a202c;
+    --gray-800: #2d3748;
+    --gray-700: #4a5568;
+    --gray-600: #718096;
+    --gray-500: #a0aec0;
+    --gray-400: #cbd5e0;
+    --gray-300: #e2e8f0;
+    --gray-200: #edf2f7;
+    --gray-100: #f7fafc;
+    --white: #ffffff;
+    --sidebar-width: 260px;
+    --header-height: 60px;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background: var(--gray-100);
+    color: var(--gray-800);
+    line-height: 1.6;
+}
+
+/* Dashboard Container */
+.dashboard-container {
+    display: flex;
+    min-height: 100vh;
+}
+
+/* Sidebar */
+.sidebar {
+    width: var(--sidebar-width);
+    background: linear-gradient(180deg, var(--gray-900) 0%, var(--gray-800) 100%);
+    color: var(--white);
+    display: flex;
+    flex-direction: column;
+    position: fixed;
+    height: 100vh;
+    z-index: 100;
+}
+
+.sidebar-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--gray-700);
+}
+
+.sidebar-header h2 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    margin-bottom: 0.25rem;
+}
+
+.role-badge {
+    font-size: 0.75rem;
+    background: var(--primary);
+    padding: 0.125rem 0.5rem;
+    border-radius: 9999px;
+    text-transform: capitalize;
+}
+
+/* Navigation */
+.sidebar-nav {
+    flex: 1;
+    padding: 1rem 0;
+    overflow-y: auto;
+}
+
+.nav-item {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem 1.5rem;
+    color: var(--gray-400);
+    text-decoration: none;
+    transition: all 0.2s;
+}
+
+.nav-item:hover {
+    background: var(--gray-700);
+    color: var(--white);
+}
+
+.nav-item.active {
+    background: linear-gradient(90deg, var(--primary) 0%, var(--secondary) 100%);
+    color: var(--white);
+}
+
+.nav-icon {
+    font-size: 1.25rem;
+    width: 1.5rem;
+    text-align: center;
+}
+
+.nav-divider {
+    height: 1px;
+    background: var(--gray-700);
+    margin: 1rem 0;
+}
+
+.nav-label {
+    display: block;
+    padding: 0.5rem 1.5rem;
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    color: var(--gray-500);
+    letter-spacing: 0.05em;
+}
+
+.sidebar-footer {
+    border-top: 1px solid var(--gray-700);
+    padding: 0.5rem 0;
+}
+
+.nav-item.logout:hover {
+    background: var(--danger);
+}
+
+/* Main Content */
+.main-content {
+    flex: 1;
+    margin-left: var(--sidebar-width);
+    min-height: 100vh;
+}
+
+.main-header {
+    height: var(--header-height);
+    background: var(--white);
+    border-bottom: 1px solid var(--gray-300);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0 2rem;
+    position: sticky;
+    top: 0;
+    z-index: 50;
+}
+
+.main-header h1 {
+    font-size: 1.5rem;
+    font-weight: 600;
+}
+
+.user-info {
+    color: var(--gray-600);
+    font-size: 0.875rem;
+}
+
+.content-wrapper {
+    padding: 2rem;
+}
+
+/* Cards */
+.card {
+    background: var(--white);
+    border-radius: 0.5rem;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    margin-bottom: 1.5rem;
+}
+
+.card-header {
+    padding: 1rem 1.5rem;
+    border-bottom: 1px solid var(--gray-200);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.card-title {
+    font-size: 1rem;
+    font-weight: 600;
+}
+
+.card-body {
+    padding: 1.5rem;
+}
+
+/* Stats Grid */
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.stat-card {
+    background: var(--white);
+    border-radius: 0.5rem;
+    padding: 1.5rem;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+}
+
+.stat-icon {
+    font-size: 2rem;
+    margin-bottom: 0.5rem;
+}
+
+.stat-value {
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--gray-900);
+}
+
+.stat-label {
+    color: var(--gray-600);
+    font-size: 0.875rem;
+}
+
+.stat-change {
+    font-size: 0.875rem;
+    margin-top: 0.25rem;
+}
+
+.stat-change.positive { color: var(--success); }
+.stat-change.negative { color: var(--danger); }
+
+/* Forms */
+.form-group {
+    margin-bottom: 1.5rem;
+}
+
+.form-label {
+    display: block;
+    font-weight: 500;
+    margin-bottom: 0.5rem;
+    color: var(--gray-700);
+}
+
+.form-input,
+.form-select,
+.form-textarea {
+    width: 100%;
+    padding: 0.75rem 1rem;
+    border: 1px solid var(--gray-300);
+    border-radius: 0.375rem;
+    font-size: 1rem;
+    transition: border-color 0.2s, box-shadow 0.2s;
+}
+
+.form-input:focus,
+.form-select:focus,
+.form-textarea:focus {
+    outline: none;
+    border-color: var(--primary);
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.2);
+}
+
+.form-help {
+    font-size: 0.875rem;
+    color: var(--gray-500);
+    margin-top: 0.25rem;
+}
+
+.form-textarea {
+    min-height: 100px;
+    resize: vertical;
+}
+
+/* Buttons */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: 0.375rem;
+    font-size: 1rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s;
+    text-decoration: none;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+    color: var(--white);
+}
+
+.btn-primary:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+}
+
+.btn-secondary {
+    background: var(--gray-200);
+    color: var(--gray-700);
+}
+
+.btn-secondary:hover {
+    background: var(--gray-300);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--white);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--white);
+}
+
+.btn-sm {
+    padding: 0.5rem 1rem;
+    font-size: 0.875rem;
+}
+
+/* Alerts */
+.alert {
+    padding: 1rem 1.5rem;
+    border-radius: 0.375rem;
+    margin-bottom: 1.5rem;
+}
+
+.alert-success {
+    background: #c6f6d5;
+    color: #22543d;
+    border: 1px solid #9ae6b4;
+}
+
+.alert-error {
+    background: #fed7d7;
+    color: #742a2a;
+    border: 1px solid #feb2b2;
+}
+
+.alert-warning {
+    background: #feebc8;
+    color: #744210;
+    border: 1px solid #fbd38d;
+}
+
+.alert-info {
+    background: #bee3f8;
+    color: #2a4365;
+    border: 1px solid #90cdf4;
+}
+
+/* Tables */
+.table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.table th,
+.table td {
+    padding: 1rem;
+    text-align: left;
+    border-bottom: 1px solid var(--gray-200);
+}
+
+.table th {
+    font-weight: 600;
+    color: var(--gray-600);
+    font-size: 0.875rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.table tbody tr:hover {
+    background: var(--gray-50);
+}
+
+/* Status Badges */
+.badge {
+    display: inline-block;
+    padding: 0.25rem 0.75rem;
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    font-weight: 500;
+}
+
+.badge-success { background: #c6f6d5; color: #22543d; }
+.badge-warning { background: #feebc8; color: #744210; }
+.badge-danger { background: #fed7d7; color: #742a2a; }
+.badge-info { background: #bee3f8; color: #2a4365; }
+
+/* Grid */
+.grid {
+    display: grid;
+    gap: 1.5rem;
+}
+
+.grid-2 { grid-template-columns: repeat(2, 1fr); }
+.grid-3 { grid-template-columns: repeat(3, 1fr); }
+
+/* Color Picker */
+.color-picker-wrapper {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.color-picker {
+    width: 50px;
+    height: 40px;
+    border: none;
+    border-radius: 0.375rem;
+    cursor: pointer;
+}
+
+.color-value {
+    font-family: monospace;
+    color: var(--gray-600);
+}
+
+/* Preview Box */
+.preview-box {
+    border: 2px dashed var(--gray-300);
+    border-radius: 0.5rem;
+    padding: 2rem;
+    text-align: center;
+    background: var(--gray-50);
+}
+
+/* Toggle Switch */
+.toggle-wrapper {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.toggle {
+    position: relative;
+    width: 48px;
+    height: 24px;
+}
+
+.toggle input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.toggle-slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: var(--gray-300);
+    border-radius: 24px;
+    transition: 0.3s;
+}
+
+.toggle-slider:before {
+    position: absolute;
+    content: "";
+    height: 18px;
+    width: 18px;
+    left: 3px;
+    bottom: 3px;
+    background: white;
+    border-radius: 50%;
+    transition: 0.3s;
+}
+
+.toggle input:checked + .toggle-slider {
+    background: var(--primary);
+}
+
+.toggle input:checked + .toggle-slider:before {
+    transform: translateX(24px);
+}
+
+/* Login Page */
+.login-container {
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+}
+
+.login-box {
+    background: var(--white);
+    padding: 2.5rem;
+    border-radius: 1rem;
+    box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+    width: 100%;
+    max-width: 400px;
+}
+
+.login-title {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+
+.login-title h1 {
+    font-size: 1.5rem;
+    margin-bottom: 0.5rem;
+}
+
+.login-title p {
+    color: var(--gray-500);
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .sidebar {
+        transform: translateX(-100%);
+        transition: transform 0.3s;
+    }
+
+    .sidebar.open {
+        transform: translateX(0);
+    }
+
+    .main-content {
+        margin-left: 0;
+    }
+
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .grid-2,
+    .grid-3 {
+        grid-template-columns: 1fr;
+    }
+}

aurora-livecam/dashboard/assets/dashboard.js

@@ -0,0 +1,131 @@
+/**
+ * Dashboard JavaScript
+ */
+
+document.addEventListener('DOMContentLoaded', function() {
+    // Auto-dismiss alerts after 5 seconds
+    const alerts = document.querySelectorAll('.alert');
+    alerts.forEach(alert => {
+        setTimeout(() => {
+            alert.style.transition = 'opacity 0.3s';
+            alert.style.opacity = '0';
+            setTimeout(() => alert.remove(), 300);
+        }, 5000);
+    });
+
+    // Mobile sidebar toggle
+    const sidebar = document.querySelector('.sidebar');
+    const mainContent = document.querySelector('.main-content');
+
+    if (window.innerWidth <= 768) {
+        // Add menu button
+        const menuBtn = document.createElement('button');
+        menuBtn.className = 'btn btn-secondary';
+        menuBtn.style.cssText = 'position: fixed; top: 10px; left: 10px; z-index: 200; padding: 0.5rem;';
+        menuBtn.innerHTML = '☰';
+        menuBtn.onclick = () => sidebar.classList.toggle('open');
+        document.body.appendChild(menuBtn);
+
+        // Close sidebar on content click
+        mainContent.addEventListener('click', () => {
+            sidebar.classList.remove('open');
+        });
+    }
+
+    // Color picker live preview
+    document.querySelectorAll('.color-picker').forEach(picker => {
+        picker.addEventListener('input', function() {
+            const wrapper = this.closest('.color-picker-wrapper');
+            if (wrapper) {
+                const valueDisplay = wrapper.querySelector('.color-value');
+                if (valueDisplay) {
+                    valueDisplay.textContent = this.value;
+                }
+            }
+        });
+    });
+
+    // Form unsaved changes warning
+    const forms = document.querySelectorAll('form');
+    let formChanged = false;
+
+    forms.forEach(form => {
+        form.addEventListener('change', () => {
+            formChanged = true;
+        });
+
+        form.addEventListener('submit', () => {
+            formChanged = false;
+        });
+    });
+
+    window.addEventListener('beforeunload', (e) => {
+        if (formChanged) {
+            e.preventDefault();
+            e.returnValue = '';
+        }
+    });
+
+    // Stats refresh (every 30 seconds on overview page)
+    if (document.querySelector('.stats-grid')) {
+        setInterval(refreshStats, 30000);
+    }
+});
+
+/**
+ * Refresh stats via AJAX
+ */
+function refreshStats() {
+    fetch('/dashboard/api/stats.php')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                updateStatCard('viewers_current', data.stats.viewers_current);
+                updateStatCard('viewers_today', data.stats.viewers_today);
+                updateStatCard('viewers_peak', data.stats.viewers_peak);
+            }
+        })
+        .catch(err => console.log('Stats refresh failed:', err));
+}
+
+/**
+ * Update a stat card value
+ */
+function updateStatCard(id, value) {
+    const cards = document.querySelectorAll('.stat-card');
+    cards.forEach(card => {
+        const label = card.querySelector('.stat-label');
+        if (label) {
+            // Match by label text (simplified)
+            const valueEl = card.querySelector('.stat-value');
+            if (valueEl && typeof value !== 'undefined') {
+                valueEl.textContent = value;
+            }
+        }
+    });
+}
+
+/**
+ * Show notification toast
+ */
+function showNotification(message, type = 'info') {
+    const toast = document.createElement('div');
+    toast.className = `alert alert-${type}`;
+    toast.style.cssText = 'position: fixed; top: 20px; right: 20px; z-index: 1000; min-width: 300px;';
+    toast.textContent = message;
+
+    document.body.appendChild(toast);
+
+    setTimeout(() => {
+        toast.style.transition = 'opacity 0.3s';
+        toast.style.opacity = '0';
+        setTimeout(() => toast.remove(), 300);
+    }, 3000);
+}
+
+/**
+ * Confirm dangerous actions
+ */
+function confirmAction(message) {
+    return confirm(message || 'Sind Sie sicher?');
+}

aurora-livecam/dashboard/billing.php

@@ -0,0 +1,282 @@
+<?php
+/**
+ * Dashboard - Abrechnung
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Billing\StripeService;
+use AuroraLivecam\Billing\SubscriptionManager;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+$auth->requireLogin();
+
+// Prüfe ob Billing aktiviert
+if (!$settingsManager->isBillingEnabled()) {
+    header('Location: /dashboard/');
+    exit;
+}
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$flashMessage = null;
+$flashType = 'info';
+
+$stripe = new StripeService();
+$subscriptions = new SubscriptionManager();
+
+// Aktuelle Subscription
+$currentSub = null;
+$plans = [];
+$invoices = [];
+$trialDays = 0;
+
+try {
+    $currentSub = $subscriptions->getSubscription($tenantId);
+    $plans = $subscriptions->getPlans();
+    $invoices = $subscriptions->getInvoices($tenantId, 5);
+    $trialDays = $subscriptions->getTrialDaysRemaining($tenantId);
+} catch (\Exception $e) {
+    $flashMessage = 'Fehler beim Laden der Abrechnungsdaten';
+    $flashType = 'error';
+}
+
+// Checkout starten
+if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['plan_id'])) {
+    $planId = (int)$_POST['plan_id'];
+    $plan = $subscriptions->getPlan($planId);
+
+    if ($plan && !empty($plan['stripe_price_id'])) {
+        $baseUrl = (isset($_SERVER['HTTPS']) ? 'https' : 'http') . '://' . $_SERVER['HTTP_HOST'];
+        $session = $stripe->createCheckoutSession(
+            $tenantId,
+            $plan['stripe_price_id'],
+            $baseUrl . '/dashboard/billing.php?success=1',
+            $baseUrl . '/dashboard/billing.php?canceled=1'
+        );
+
+        if ($session && isset($session['url'])) {
+            header('Location: ' . $session['url']);
+            exit;
+        } else {
+            $flashMessage = 'Fehler beim Erstellen der Checkout-Session';
+            $flashType = 'error';
+        }
+    }
+}
+
+// Billing Portal öffnen
+if (isset($_GET['portal'])) {
+    $baseUrl = (isset($_SERVER['HTTPS']) ? 'https' : 'http') . '://' . $_SERVER['HTTP_HOST'];
+    $session = $stripe->createPortalSession($tenantId, $baseUrl . '/dashboard/billing.php');
+
+    if ($session && isset($session['url'])) {
+        header('Location: ' . $session['url']);
+        exit;
+    }
+}
+
+// Success/Cancel Messages
+if (isset($_GET['success'])) {
+    $flashMessage = 'Zahlung erfolgreich! Ihr Abo ist jetzt aktiv.';
+    $flashType = 'success';
+}
+if (isset($_GET['canceled'])) {
+    $flashMessage = 'Checkout abgebrochen.';
+    $flashType = 'warning';
+}
+
+$pageTitle = 'Abrechnung';
+$currentPage = 'billing';
+
+ob_start();
+?>
+
+<!-- Aktueller Plan -->
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Aktueller Plan</h3>
+        <?php if ($currentSub): ?>
+        <span class="badge badge-<?php echo $currentSub['status'] === 'active' ? 'success' : ($currentSub['status'] === 'trialing' ? 'warning' : 'danger'); ?>">
+            <?php echo ucfirst($currentSub['status']); ?>
+        </span>
+        <?php endif; ?>
+    </div>
+    <div class="card-body">
+        <?php if ($currentSub): ?>
+        <div style="display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 1rem;">
+            <div>
+                <h2 style="margin: 0; font-size: 1.75rem;"><?php echo htmlspecialchars($currentSub['plan_name'] ?? 'Free'); ?></h2>
+                <?php if ($currentSub['status'] === 'trialing' && $trialDays > 0): ?>
+                <p style="color: var(--warning); margin: 0.5rem 0 0 0;">
+                    Trial endet in <?php echo $trialDays; ?> Tag<?php echo $trialDays !== 1 ? 'en' : ''; ?>
+                </p>
+                <?php elseif ($currentSub['current_period_end']): ?>
+                <p style="color: var(--gray-500); margin: 0.5rem 0 0 0;">
+                    Nächste Abrechnung: <?php echo date('d.m.Y', strtotime($currentSub['current_period_end'])); ?>
+                </p>
+                <?php endif; ?>
+            </div>
+            <?php if ($stripe->isConfigured() && !empty($currentSub['stripe_customer_id'])): ?>
+            <a href="?portal=1" class="btn btn-secondary">
+                Abo verwalten
+            </a>
+            <?php endif; ?>
+        </div>
+
+        <?php if (!empty($currentSub['plan_features'])): ?>
+        <div style="margin-top: 1.5rem; padding-top: 1.5rem; border-top: 1px solid var(--gray-200);">
+            <h4 style="font-size: 0.875rem; color: var(--gray-500); margin-bottom: 0.75rem;">Enthaltene Features:</h4>
+            <div style="display: flex; flex-wrap: wrap; gap: 0.5rem;">
+                <?php foreach ($currentSub['plan_features'] as $feature => $value): ?>
+                <?php if ($value): ?>
+                <span class="badge badge-info">
+                    <?php
+                    $labels = [
+                        'max_viewers' => 'Max. Zuschauer: ' . ($value === -1 ? '∞' : $value),
+                        'storage_gb' => 'Speicher: ' . $value . ' GB',
+                        'custom_domain' => 'Custom Domain',
+                        'weather_widget' => 'Wetter-Widget',
+                        'timelapse' => 'Timelapse',
+                        'analytics' => 'Analytics',
+                        'branding' => 'Custom Branding',
+                        'priority_support' => 'Priority Support',
+                    ];
+                    echo $labels[$feature] ?? ucfirst(str_replace('_', ' ', $feature));
+                    ?>
+                </span>
+                <?php endif; ?>
+                <?php endforeach; ?>
+            </div>
+        </div>
+        <?php endif; ?>
+        <?php else: ?>
+        <p style="color: var(--gray-500);">Kein aktives Abo</p>
+        <?php endif; ?>
+    </div>
+</div>
+
+<!-- Verfügbare Pläne -->
+<?php if (!empty($plans)): ?>
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Verfügbare Pläne</h3>
+    </div>
+    <div class="card-body">
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 1.5rem;">
+            <?php foreach ($plans as $plan): ?>
+            <?php $isCurrent = $currentSub && $currentSub['plan_id'] == $plan['id']; ?>
+            <div style="border: 2px solid <?php echo $isCurrent ? 'var(--primary)' : 'var(--gray-200)'; ?>; border-radius: 0.75rem; padding: 1.5rem; <?php echo $isCurrent ? 'background: rgba(102,126,234,0.05);' : ''; ?>">
+                <h4 style="margin: 0 0 0.5rem 0;"><?php echo htmlspecialchars($plan['name']); ?></h4>
+                <div style="font-size: 2rem; font-weight: 700; color: var(--gray-900);">
+                    <?php if ($plan['price_monthly'] > 0): ?>
+                    CHF <?php echo number_format($plan['price_monthly'], 0); ?>
+                    <span style="font-size: 1rem; font-weight: 400; color: var(--gray-500);">/Monat</span>
+                    <?php else: ?>
+                    Kostenlos
+                    <?php endif; ?>
+                </div>
+
+                <?php if (!empty($plan['features'])): ?>
+                <ul style="list-style: none; padding: 0; margin: 1rem 0; font-size: 0.875rem;">
+                    <?php foreach ($plan['features'] as $feature => $value): ?>
+                    <?php if ($value): ?>
+                    <li style="padding: 0.25rem 0; color: var(--gray-600);">
+                        ✓ <?php
+                        $labels = [
+                            'max_viewers' => 'Bis ' . ($value === -1 ? 'unbegrenzt' : $value) . ' Zuschauer',
+                            'storage_gb' => $value . ' GB Speicher',
+                            'custom_domain' => 'Eigene Domain',
+                            'weather_widget' => 'Wetter-Widget',
+                            'timelapse' => 'Timelapse',
+                            'analytics' => 'Analytics',
+                            'branding' => 'Custom Branding',
+                            'priority_support' => 'Priority Support',
+                        ];
+                        echo $labels[$feature] ?? ucfirst(str_replace('_', ' ', $feature));
+                        ?>
+                    </li>
+                    <?php endif; ?>
+                    <?php endforeach; ?>
+                </ul>
+                <?php endif; ?>
+
+                <?php if ($isCurrent): ?>
+                <button class="btn btn-secondary" style="width: 100%;" disabled>Aktueller Plan</button>
+                <?php elseif ($plan['price_monthly'] > 0 && $stripe->isConfigured()): ?>
+                <form method="POST" action="">
+                    <input type="hidden" name="plan_id" value="<?php echo $plan['id']; ?>">
+                    <button type="submit" class="btn btn-primary" style="width: 100%;">
+                        Upgrade
+                    </button>
+                </form>
+                <?php elseif ($plan['price_monthly'] == 0): ?>
+                <button class="btn btn-secondary" style="width: 100%;" disabled>Free Plan</button>
+                <?php else: ?>
+                <button class="btn btn-secondary" style="width: 100%;" disabled>Stripe nicht konfiguriert</button>
+                <?php endif; ?>
+            </div>
+            <?php endforeach; ?>
+        </div>
+    </div>
+</div>
+<?php endif; ?>
+
+<!-- Rechnungen -->
+<?php if (!empty($invoices)): ?>
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Rechnungen</h3>
+    </div>
+    <div class="card-body">
+        <table class="table">
+            <thead>
+                <tr>
+                    <th>Datum</th>
+                    <th>Betrag</th>
+                    <th>Status</th>
+                    <th>PDF</th>
+                </tr>
+            </thead>
+            <tbody>
+                <?php foreach ($invoices as $invoice): ?>
+                <tr>
+                    <td><?php echo date('d.m.Y', strtotime($invoice['created_at'])); ?></td>
+                    <td><?php echo $invoice['currency']; ?> <?php echo number_format($invoice['amount'], 2); ?></td>
+                    <td>
+                        <span class="badge badge-<?php echo $invoice['status'] === 'paid' ? 'success' : 'warning'; ?>">
+                            <?php echo ucfirst($invoice['status']); ?>
+                        </span>
+                    </td>
+                    <td>
+                        <?php if ($invoice['invoice_pdf_url']): ?>
+                        <a href="<?php echo htmlspecialchars($invoice['invoice_pdf_url']); ?>" target="_blank" class="btn btn-sm btn-secondary">
+                            Download
+                        </a>
+                        <?php endif; ?>
+                    </td>
+                </tr>
+                <?php endforeach; ?>
+            </tbody>
+        </table>
+    </div>
+</div>
+<?php endif; ?>
+
+<?php if (!$stripe->isConfigured()): ?>
+<div class="alert alert-warning">
+    <strong>Hinweis:</strong> Stripe ist noch nicht konfiguriert. Bitte fügen Sie Ihre Stripe API-Keys in config.php hinzu.
+</div>
+<?php endif; ?>
+
+<?php
+$content = ob_get_clean();
+include __DIR__ . '/templates/layout.php';

aurora-livecam/dashboard/branding.php

@@ -0,0 +1,230 @@
+<?php
+/**
+ * Dashboard - Branding Einstellungen
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Core\Database;
+use AuroraLivecam\Tenant\TenantManager;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+$auth->requireLogin();
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$flashMessage = null;
+$flashType = 'info';
+
+// Branding-Daten laden
+$branding = [
+    'site_name' => '',
+    'site_name_full' => '',
+    'tagline' => '',
+    'primary_color' => '#667eea',
+    'secondary_color' => '#764ba2',
+    'accent_color' => '#f093fb',
+    'welcome_text_de' => '',
+    'welcome_text_en' => '',
+    'footer_text' => '',
+    'custom_css' => '',
+];
+
+try {
+    $db = Database::getInstance();
+    if ($tenantId > 0) {
+        $tenantManager = new TenantManager($db);
+        $dbBranding = $tenantManager->getBranding($tenantId);
+        if ($dbBranding) {
+            $branding = array_merge($branding, $dbBranding);
+        }
+    }
+} catch (\Exception $e) {
+    // DB nicht verfügbar
+}
+
+// Formular verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $newBranding = [
+        'site_name' => trim($_POST['site_name'] ?? ''),
+        'site_name_full' => trim($_POST['site_name_full'] ?? ''),
+        'tagline' => trim($_POST['tagline'] ?? ''),
+        'primary_color' => $_POST['primary_color'] ?? '#667eea',
+        'secondary_color' => $_POST['secondary_color'] ?? '#764ba2',
+        'accent_color' => $_POST['accent_color'] ?? '#f093fb',
+        'welcome_text_de' => trim($_POST['welcome_text_de'] ?? ''),
+        'welcome_text_en' => trim($_POST['welcome_text_en'] ?? ''),
+        'footer_text' => trim($_POST['footer_text'] ?? ''),
+        'custom_css' => trim($_POST['custom_css'] ?? ''),
+    ];
+
+    try {
+        $db = Database::getInstance();
+        if ($tenantId > 0) {
+            $tenantManager = new TenantManager($db);
+            $tenantManager->updateBranding($tenantId, $newBranding);
+
+            $flashMessage = 'Branding gespeichert!';
+            $flashType = 'success';
+            $branding = array_merge($branding, $newBranding);
+        } else {
+            $flashMessage = 'Branding kann im Legacy-Modus nicht gespeichert werden.';
+            $flashType = 'warning';
+        }
+    } catch (\Exception $e) {
+        $flashMessage = 'Fehler beim Speichern: ' . $e->getMessage();
+        $flashType = 'error';
+    }
+}
+
+$pageTitle = 'Branding';
+$currentPage = 'branding';
+
+ob_start();
+?>
+
+<form method="POST" action="">
+    <div class="grid grid-2">
+        <!-- Grundeinstellungen -->
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Grundeinstellungen</h3>
+            </div>
+            <div class="card-body">
+                <div class="form-group">
+                    <label class="form-label" for="site_name">Site Name (kurz)</label>
+                    <input type="text" id="site_name" name="site_name" class="form-input"
+                           value="<?php echo htmlspecialchars($branding['site_name']); ?>"
+                           placeholder="MeineCam">
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="site_name_full">Site Name (vollständig)</label>
+                    <input type="text" id="site_name_full" name="site_name_full" class="form-input"
+                           value="<?php echo htmlspecialchars($branding['site_name_full']); ?>"
+                           placeholder="Meine Wetter Livecam">
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="tagline">Tagline / Slogan</label>
+                    <input type="text" id="tagline" name="tagline" class="form-input"
+                           value="<?php echo htmlspecialchars($branding['tagline']); ?>"
+                           placeholder="Ihre Live-Webcam 24/7">
+                </div>
+            </div>
+        </div>
+
+        <!-- Farben -->
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Farben</h3>
+            </div>
+            <div class="card-body">
+                <div class="form-group">
+                    <label class="form-label">Primärfarbe</label>
+                    <div class="color-picker-wrapper">
+                        <input type="color" name="primary_color" class="color-picker"
+                               value="<?php echo htmlspecialchars($branding['primary_color']); ?>">
+                        <span class="color-value"><?php echo htmlspecialchars($branding['primary_color']); ?></span>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Sekundärfarbe</label>
+                    <div class="color-picker-wrapper">
+                        <input type="color" name="secondary_color" class="color-picker"
+                               value="<?php echo htmlspecialchars($branding['secondary_color']); ?>">
+                        <span class="color-value"><?php echo htmlspecialchars($branding['secondary_color']); ?></span>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Akzentfarbe</label>
+                    <div class="color-picker-wrapper">
+                        <input type="color" name="accent_color" class="color-picker"
+                               value="<?php echo htmlspecialchars($branding['accent_color']); ?>">
+                        <span class="color-value"><?php echo htmlspecialchars($branding['accent_color']); ?></span>
+                    </div>
+                </div>
+
+                <!-- Vorschau -->
+                <div style="margin-top: 1rem; padding: 1rem; border-radius: 0.5rem;
+                            background: linear-gradient(135deg, <?php echo htmlspecialchars($branding['primary_color']); ?> 0%, <?php echo htmlspecialchars($branding['secondary_color']); ?> 100%);">
+                    <span style="color: white; font-weight: bold;">Farbvorschau</span>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Texte -->
+    <div class="card">
+        <div class="card-header">
+            <h3 class="card-title">Willkommenstexte</h3>
+        </div>
+        <div class="card-body">
+            <div class="grid grid-2">
+                <div class="form-group">
+                    <label class="form-label" for="welcome_text_de">Willkommenstext (Deutsch)</label>
+                    <textarea id="welcome_text_de" name="welcome_text_de" class="form-textarea"
+                              placeholder="Willkommen bei unserer Livecam..."><?php echo htmlspecialchars($branding['welcome_text_de']); ?></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="welcome_text_en">Welcome Text (English)</label>
+                    <textarea id="welcome_text_en" name="welcome_text_en" class="form-textarea"
+                              placeholder="Welcome to our livecam..."><?php echo htmlspecialchars($branding['welcome_text_en']); ?></textarea>
+                </div>
+            </div>
+
+            <div class="form-group">
+                <label class="form-label" for="footer_text">Footer Text</label>
+                <input type="text" id="footer_text" name="footer_text" class="form-input"
+                       value="<?php echo htmlspecialchars($branding['footer_text']); ?>"
+                       placeholder="© 2024 Ihre Livecam">
+            </div>
+        </div>
+    </div>
+
+    <!-- Custom CSS -->
+    <div class="card">
+        <div class="card-header">
+            <h3 class="card-title">Eigenes CSS</h3>
+        </div>
+        <div class="card-body">
+            <div class="form-group">
+                <label class="form-label" for="custom_css">Custom CSS (optional)</label>
+                <textarea id="custom_css" name="custom_css" class="form-textarea"
+                          style="font-family: monospace; min-height: 150px;"
+                          placeholder="/* Eigene CSS-Regeln hier */"><?php echo htmlspecialchars($branding['custom_css']); ?></textarea>
+                <p class="form-help">Fortgeschrittene Benutzer können hier eigene CSS-Regeln hinzufügen.</p>
+            </div>
+        </div>
+    </div>
+
+    <div style="margin-top: 1.5rem;">
+        <button type="submit" class="btn btn-primary">
+            Branding speichern
+        </button>
+    </div>
+</form>
+
+<script>
+// Color picker update
+document.querySelectorAll('.color-picker').forEach(picker => {
+    picker.addEventListener('input', (e) => {
+        e.target.parentNode.querySelector('.color-value').textContent = e.target.value;
+    });
+});
+</script>
+
+<?php
+$content = ob_get_clean();
+include __DIR__ . '/templates/layout.php';

aurora-livecam/dashboard/index.php

@@ -0,0 +1,147 @@
+<?php
+/**
+ * Dashboard - Übersicht
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Core\Database;
+use AuroraLivecam\Core\TenantResolver;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+
+// Login erforderlich
+$auth->requireLogin();
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+// Stats laden
+$stats = [
+    'viewers_current' => 0,
+    'viewers_today' => 0,
+    'viewers_peak' => 0,
+    'stream_status' => 'unknown',
+];
+
+// Versuche Stats aus DB zu laden
+try {
+    $db = Database::getInstance();
+
+    if ($tenantId > 0) {
+        // Aktuelle Zuschauer (vereinfacht)
+        $viewerFile = dirname(__DIR__) . '/active_viewers.json';
+        if (file_exists($viewerFile)) {
+            $viewers = json_decode(file_get_contents($viewerFile), true);
+            $stats['viewers_current'] = count($viewers ?? []);
+        }
+
+        // Heute Stats
+        $todayStats = $db->fetchOne(
+            "SELECT SUM(viewer_count) as total, MAX(viewer_count) as peak
+             FROM viewer_stats
+             WHERE tenant_id = ? AND DATE(recorded_at) = CURDATE()",
+            [$tenantId]
+        );
+
+        if ($todayStats) {
+            $stats['viewers_today'] = $todayStats['total'] ?? 0;
+            $stats['viewers_peak'] = $todayStats['peak'] ?? 0;
+        }
+
+        // Stream Status
+        $stream = $db->fetchOne(
+            "SELECT last_status FROM tenant_streams WHERE tenant_id = ? AND is_primary = 1",
+            [$tenantId]
+        );
+        $stats['stream_status'] = $stream['last_status'] ?? 'unknown';
+    }
+} catch (\Exception $e) {
+    // DB nicht verfügbar - Legacy-Modus
+    $viewerFile = dirname(__DIR__) . '/active_viewers.json';
+    if (file_exists($viewerFile)) {
+        $viewers = json_decode(file_get_contents($viewerFile), true);
+        $stats['viewers_current'] = count($viewers ?? []);
+    }
+}
+
+// Page Setup
+$pageTitle = 'Übersicht';
+$currentPage = 'overview';
+
+ob_start();
+?>
+
+<!-- Stats Grid -->
+<div class="stats-grid">
+    <div class="stat-card">
+        <div class="stat-icon">👥</div>
+        <div class="stat-value"><?php echo $stats['viewers_current']; ?></div>
+        <div class="stat-label">Aktuelle Zuschauer</div>
+    </div>
+
+    <div class="stat-card">
+        <div class="stat-icon">📊</div>
+        <div class="stat-value"><?php echo $stats['viewers_today']; ?></div>
+        <div class="stat-label">Zuschauer heute</div>
+    </div>
+
+    <div class="stat-card">
+        <div class="stat-icon">🏆</div>
+        <div class="stat-value"><?php echo $stats['viewers_peak']; ?></div>
+        <div class="stat-label">Peak heute</div>
+    </div>
+
+    <div class="stat-card">
+        <div class="stat-icon">
+            <?php echo $stats['stream_status'] === 'online' ? '🟢' : ($stats['stream_status'] === 'offline' ? '🔴' : '⚪'); ?>
+        </div>
+        <div class="stat-value" style="font-size: 1.25rem; text-transform: capitalize;">
+            <?php echo $stats['stream_status'] === 'online' ? 'Online' : ($stats['stream_status'] === 'offline' ? 'Offline' : 'Unbekannt'); ?>
+        </div>
+        <div class="stat-label">Stream Status</div>
+    </div>
+</div>
+
+<!-- Quick Actions -->
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Schnellzugriff</h3>
+    </div>
+    <div class="card-body">
+        <div class="grid grid-3">
+            <a href="/dashboard/stream.php" class="btn btn-secondary">
+                📹 Stream bearbeiten
+            </a>
+            <a href="/dashboard/branding.php" class="btn btn-secondary">
+                🎨 Branding anpassen
+            </a>
+            <a href="/dashboard/settings.php" class="btn btn-secondary">
+                ⚙️ Einstellungen
+            </a>
+        </div>
+    </div>
+</div>
+
+<!-- Recent Activity (Platzhalter) -->
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Letzte Aktivitäten</h3>
+    </div>
+    <div class="card-body">
+        <p style="color: var(--gray-500); text-align: center; padding: 2rem;">
+            Aktivitäten werden hier angezeigt, sobald Analytics aktiviert ist.
+        </p>
+    </div>
+</div>
+
+<?php
+$content = ob_get_clean();
+include __DIR__ . '/templates/layout.php';

aurora-livecam/dashboard/login.php

@@ -0,0 +1,102 @@
+<?php
+/**
+ * Dashboard Login
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+
+$settingsManager = new SettingsManager();
+
+// Prüfe ob Dashboard aktiviert ist
+if (!$settingsManager->isTenantDashboardEnabled() && !$settingsManager->isMultiTenantEnabled()) {
+    // Fallback auf Legacy-Admin
+    header('Location: /?admin=1');
+    exit;
+}
+
+$auth = new AuthManager();
+
+// Bereits eingeloggt?
+if ($auth->isLoggedIn()) {
+    header('Location: /dashboard/');
+    exit;
+}
+
+$error = '';
+
+// Login verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $email = $_POST['email'] ?? '';
+    $password = $_POST['password'] ?? '';
+    $remember = isset($_POST['remember']);
+
+    if ($auth->login($email, $password, $remember)) {
+        header('Location: /dashboard/');
+        exit;
+    } else {
+        $error = 'Ungültige Anmeldedaten';
+    }
+}
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Login - Dashboard</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+</head>
+<body>
+    <div class="login-container">
+        <div class="login-box">
+            <div class="login-title">
+                <h1>Dashboard Login</h1>
+                <p>Melden Sie sich an, um fortzufahren</p>
+            </div>
+
+            <?php if ($error): ?>
+            <div class="alert alert-error"><?php echo htmlspecialchars($error); ?></div>
+            <?php endif; ?>
+
+            <form method="POST" action="">
+                <div class="form-group">
+                    <label class="form-label" for="email">E-Mail / Benutzername</label>
+                    <input type="text" id="email" name="email" class="form-input"
+                           value="<?php echo htmlspecialchars($_POST['email'] ?? ''); ?>"
+                           required autofocus>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="password">Passwort</label>
+                    <input type="password" id="password" name="password" class="form-input" required>
+                </div>
+
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="remember">
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Angemeldet bleiben</span>
+                    </label>
+                </div>
+
+                <button type="submit" class="btn btn-primary" style="width: 100%;">
+                    Anmelden
+                </button>
+            </form>
+
+            <p style="text-align: center; margin-top: 1.5rem; color: var(--gray-500);">
+                <a href="/" style="color: var(--primary);">Zurück zur Livecam</a>
+            </p>
+        </div>
+    </div>
+</body>
+</html>

aurora-livecam/dashboard/logout.php

@@ -0,0 +1,18 @@
+<?php
+/**
+ * Dashboard Logout
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+
+$auth = new AuthManager();
+$auth->logout();
+
+header('Location: /dashboard/login.php');
+exit;

aurora-livecam/dashboard/settings.php

@@ -0,0 +1,271 @@
+<?php
+/**
+ * Dashboard - Einstellungen
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Tenant\TenantSettingsManager;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+$auth->requireLogin();
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$flashMessage = null;
+$flashType = 'info';
+
+// Tenant-Settings laden
+try {
+    $tenantSettings = new TenantSettingsManager($tenantId);
+} catch (\Exception $e) {
+    $tenantSettings = null;
+}
+
+// Einstellungen für das Template
+$settings = [
+    'viewer_display_enabled' => $settingsManager->get('viewer_display.enabled') ?? true,
+    'viewer_min' => $settingsManager->get('viewer_display.min_viewers') ?? 1,
+    'weather_enabled' => $settingsManager->get('weather.enabled') ?? true,
+    'weather_location' => $settingsManager->get('weather.location') ?? 'Zürich,CH',
+    'weather_lat' => $settingsManager->get('weather.lat') ?? '47.3769',
+    'weather_lon' => $settingsManager->get('weather.lon') ?? '8.5417',
+    'guestbook_enabled' => $settingsManager->get('content.guestbook_enabled') ?? true,
+    'gallery_enabled' => $settingsManager->get('content.gallery_enabled') ?? true,
+    'ai_events_enabled' => $settingsManager->get('content.ai_events_enabled') ?? true,
+    'show_qr_code' => $settingsManager->get('ui_display.show_qr_code') ?? true,
+    'show_social_media' => $settingsManager->get('ui_display.show_social_media') ?? true,
+    'timelapse_reverse' => $settingsManager->get('zoom_timelapse.timelapse_reverse_enabled') ?? true,
+    'max_zoom' => $settingsManager->get('zoom_timelapse.max_zoom_level') ?? 4.0,
+];
+
+// Formular verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $updates = [
+        'viewer_display.enabled' => isset($_POST['viewer_display_enabled']),
+        'viewer_display.min_viewers' => (int)($_POST['viewer_min'] ?? 1),
+        'weather.enabled' => isset($_POST['weather_enabled']),
+        'weather.location' => trim($_POST['weather_location'] ?? ''),
+        'weather.lat' => trim($_POST['weather_lat'] ?? ''),
+        'weather.lon' => trim($_POST['weather_lon'] ?? ''),
+        'content.guestbook_enabled' => isset($_POST['guestbook_enabled']),
+        'content.gallery_enabled' => isset($_POST['gallery_enabled']),
+        'content.ai_events_enabled' => isset($_POST['ai_events_enabled']),
+        'ui_display.show_qr_code' => isset($_POST['show_qr_code']),
+        'ui_display.show_social_media' => isset($_POST['show_social_media']),
+        'zoom_timelapse.timelapse_reverse_enabled' => isset($_POST['timelapse_reverse']),
+        'zoom_timelapse.max_zoom_level' => (float)($_POST['max_zoom'] ?? 4.0),
+    ];
+
+    $success = true;
+    foreach ($updates as $key => $value) {
+        if (!$settingsManager->set($key, $value)) {
+            $success = false;
+        }
+    }
+
+    if ($success) {
+        $flashMessage = 'Einstellungen gespeichert!';
+        $flashType = 'success';
+
+        // Reload settings
+        $settings = [
+            'viewer_display_enabled' => $updates['viewer_display.enabled'],
+            'viewer_min' => $updates['viewer_display.min_viewers'],
+            'weather_enabled' => $updates['weather.enabled'],
+            'weather_location' => $updates['weather.location'],
+            'weather_lat' => $updates['weather.lat'],
+            'weather_lon' => $updates['weather.lon'],
+            'guestbook_enabled' => $updates['content.guestbook_enabled'],
+            'gallery_enabled' => $updates['content.gallery_enabled'],
+            'ai_events_enabled' => $updates['content.ai_events_enabled'],
+            'show_qr_code' => $updates['ui_display.show_qr_code'],
+            'show_social_media' => $updates['ui_display.show_social_media'],
+            'timelapse_reverse' => $updates['zoom_timelapse.timelapse_reverse_enabled'],
+            'max_zoom' => $updates['zoom_timelapse.max_zoom_level'],
+        ];
+    } else {
+        $flashMessage = 'Fehler beim Speichern einiger Einstellungen.';
+        $flashType = 'error';
+    }
+}
+
+$pageTitle = 'Einstellungen';
+$currentPage = 'settings';
+
+ob_start();
+?>
+
+<form method="POST" action="">
+    <div class="grid grid-2">
+        <!-- Viewer-Anzeige -->
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Zuschauer-Anzeige</h3>
+            </div>
+            <div class="card-body">
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="viewer_display_enabled"
+                                   <?php echo $settings['viewer_display_enabled'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Zuschauer-Anzahl anzeigen</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="viewer_min">Mindestanzahl für Anzeige</label>
+                    <input type="number" id="viewer_min" name="viewer_min" class="form-input"
+                           value="<?php echo (int)$settings['viewer_min']; ?>" min="0" max="100">
+                    <p class="form-help">Zuschauer werden erst ab dieser Anzahl angezeigt</p>
+                </div>
+            </div>
+        </div>
+
+        <!-- Wetter-Widget -->
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Wetter-Widget</h3>
+            </div>
+            <div class="card-body">
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="weather_enabled"
+                                   <?php echo $settings['weather_enabled'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Wetter-Widget aktivieren</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="weather_location">Standort-Name</label>
+                    <input type="text" id="weather_location" name="weather_location" class="form-input"
+                           value="<?php echo htmlspecialchars($settings['weather_location']); ?>">
+                </div>
+
+                <div class="grid grid-2">
+                    <div class="form-group">
+                        <label class="form-label" for="weather_lat">Breitengrad</label>
+                        <input type="text" id="weather_lat" name="weather_lat" class="form-input"
+                               value="<?php echo htmlspecialchars($settings['weather_lat']); ?>">
+                    </div>
+                    <div class="form-group">
+                        <label class="form-label" for="weather_lon">Längengrad</label>
+                        <input type="text" id="weather_lon" name="weather_lon" class="form-input"
+                               value="<?php echo htmlspecialchars($settings['weather_lon']); ?>">
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Content -->
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Inhalte</h3>
+            </div>
+            <div class="card-body">
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="guestbook_enabled"
+                                   <?php echo $settings['guestbook_enabled'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Gästebuch aktivieren</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="gallery_enabled"
+                                   <?php echo $settings['gallery_enabled'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Galerie aktivieren</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="ai_events_enabled"
+                                   <?php echo $settings['ai_events_enabled'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>AI-Events aktivieren</span>
+                    </label>
+                </div>
+            </div>
+        </div>
+
+        <!-- UI -->
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Oberfläche</h3>
+            </div>
+            <div class="card-body">
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="show_qr_code"
+                                   <?php echo $settings['show_qr_code'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>QR-Code anzeigen</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="show_social_media"
+                                   <?php echo $settings['show_social_media'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Social Media Links anzeigen</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <span class="toggle">
+                            <input type="checkbox" name="timelapse_reverse"
+                                   <?php echo $settings['timelapse_reverse'] ? 'checked' : ''; ?>>
+                            <span class="toggle-slider"></span>
+                        </span>
+                        <span>Timelapse Rückwärts erlauben</span>
+                    </label>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="max_zoom">Maximaler Zoom</label>
+                    <input type="number" id="max_zoom" name="max_zoom" class="form-input"
+                           value="<?php echo (float)$settings['max_zoom']; ?>" min="1" max="10" step="0.5">
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div style="margin-top: 1.5rem;">
+        <button type="submit" class="btn btn-primary">
+            Einstellungen speichern
+        </button>
+    </div>
+</form>
+
+<?php
+$content = ob_get_clean();
+include __DIR__ . '/templates/layout.php';

aurora-livecam/dashboard/stream.php

@@ -0,0 +1,183 @@
+<?php
+/**
+ * Dashboard - Stream Einstellungen
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Core\Database;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+$auth->requireLogin();
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$flashMessage = null;
+$flashType = 'info';
+
+// Stream-Daten laden
+$stream = [
+    'stream_url' => '',
+    'stream_type' => 'hls',
+    'is_active' => true,
+    'last_status' => 'unknown',
+];
+
+try {
+    $db = Database::getInstance();
+    if ($tenantId > 0) {
+        $dbStream = $db->fetchOne(
+            "SELECT * FROM tenant_streams WHERE tenant_id = ? AND is_primary = 1",
+            [$tenantId]
+        );
+        if ($dbStream) {
+            $stream = $dbStream;
+        }
+    }
+} catch (\Exception $e) {
+    // DB nicht verfügbar
+}
+
+// Formular verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $streamUrl = trim($_POST['stream_url'] ?? '');
+    $streamType = $_POST['stream_type'] ?? 'hls';
+
+    if (empty($streamUrl)) {
+        $flashMessage = 'Bitte geben Sie eine Stream-URL ein.';
+        $flashType = 'error';
+    } else {
+        try {
+            $db = Database::getInstance();
+
+            if ($tenantId > 0) {
+                // Prüfe ob Stream existiert
+                $existing = $db->fetchOne(
+                    "SELECT id FROM tenant_streams WHERE tenant_id = ? AND is_primary = 1",
+                    [$tenantId]
+                );
+
+                if ($existing) {
+                    $db->update('tenant_streams', [
+                        'stream_url' => $streamUrl,
+                        'stream_type' => $streamType,
+                    ], 'id = ?', [$existing['id']]);
+                } else {
+                    $db->insert('tenant_streams', [
+                        'tenant_id' => $tenantId,
+                        'stream_url' => $streamUrl,
+                        'stream_type' => $streamType,
+                        'is_primary' => 1,
+                    ]);
+                }
+
+                $flashMessage = 'Stream-Einstellungen gespeichert!';
+                $flashType = 'success';
+
+                // Reload stream data
+                $stream['stream_url'] = $streamUrl;
+                $stream['stream_type'] = $streamType;
+            } else {
+                $flashMessage = 'Stream-Einstellungen können im Legacy-Modus nicht gespeichert werden.';
+                $flashType = 'warning';
+            }
+        } catch (\Exception $e) {
+            $flashMessage = 'Fehler beim Speichern: ' . $e->getMessage();
+            $flashType = 'error';
+        }
+    }
+}
+
+$pageTitle = 'Stream Einstellungen';
+$currentPage = 'stream';
+
+ob_start();
+?>
+
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Stream Konfiguration</h3>
+        <span class="badge badge-<?php echo $stream['last_status'] === 'online' ? 'success' : ($stream['last_status'] === 'offline' ? 'danger' : 'info'); ?>">
+            <?php echo ucfirst($stream['last_status'] ?? 'Unbekannt'); ?>
+        </span>
+    </div>
+    <div class="card-body">
+        <form method="POST" action="">
+            <div class="form-group">
+                <label class="form-label" for="stream_url">Stream URL</label>
+                <input type="url" id="stream_url" name="stream_url" class="form-input"
+                       value="<?php echo htmlspecialchars($stream['stream_url']); ?>"
+                       placeholder="https://example.com/stream.m3u8">
+                <p class="form-help">Die URL zu Ihrem HLS-Stream (.m3u8) oder RTMP-Stream</p>
+            </div>
+
+            <div class="form-group">
+                <label class="form-label" for="stream_type">Stream Typ</label>
+                <select id="stream_type" name="stream_type" class="form-select">
+                    <option value="hls" <?php echo ($stream['stream_type'] ?? 'hls') === 'hls' ? 'selected' : ''; ?>>
+                        HLS (.m3u8)
+                    </option>
+                    <option value="rtmp" <?php echo ($stream['stream_type'] ?? '') === 'rtmp' ? 'selected' : ''; ?>>
+                        RTMP
+                    </option>
+                    <option value="webrtc" <?php echo ($stream['stream_type'] ?? '') === 'webrtc' ? 'selected' : ''; ?>>
+                        WebRTC
+                    </option>
+                    <option value="iframe" <?php echo ($stream['stream_type'] ?? '') === 'iframe' ? 'selected' : ''; ?>>
+                        iFrame Embed
+                    </option>
+                </select>
+            </div>
+
+            <button type="submit" class="btn btn-primary">
+                Speichern
+            </button>
+        </form>
+    </div>
+</div>
+
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Stream Vorschau</h3>
+    </div>
+    <div class="card-body">
+        <?php if (!empty($stream['stream_url'])): ?>
+        <div style="aspect-ratio: 16/9; background: #000; border-radius: 0.5rem; overflow: hidden;">
+            <video id="preview-player" controls style="width: 100%; height: 100%;">
+                <source src="<?php echo htmlspecialchars($stream['stream_url']); ?>" type="application/x-mpegURL">
+            </video>
+        </div>
+        <p class="form-help" style="margin-top: 1rem;">
+            Hinweis: Die Vorschau funktioniert nur mit HLS-Streams und wenn Ihr Browser HLS unterstützt.
+        </p>
+        <?php else: ?>
+        <div class="preview-box">
+            <p>Keine Stream-URL konfiguriert</p>
+        </div>
+        <?php endif; ?>
+    </div>
+</div>
+
+<div class="card">
+    <div class="card-header">
+        <h3 class="card-title">Stream Monitoring</h3>
+    </div>
+    <div class="card-body">
+        <p style="color: var(--gray-500);">
+            Stream-Monitoring zeigt automatische Verfügbarkeitsprüfungen an.
+            Diese Funktion wird demnächst verfügbar sein.
+        </p>
+    </div>
+</div>
+
+<?php
+$content = ob_get_clean();
+include __DIR__ . '/templates/layout.php';

aurora-livecam/dashboard/templates/layout.php

@@ -0,0 +1,126 @@
+<?php
+/**
+ * Dashboard Layout Template
+ *
+ * Variablen:
+ * - $pageTitle: Seitentitel
+ * - $currentPage: Aktuelle Seite (für Navigation)
+ * - $content: Hauptinhalt
+ */
+
+$user = $auth->getUser();
+$tenantName = $user['tenant_name'] ?? 'Dashboard';
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?php echo htmlspecialchars($pageTitle ?? 'Dashboard'); ?> - <?php echo htmlspecialchars($tenantName); ?></title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+</head>
+<body>
+    <div class="dashboard-container">
+        <!-- Sidebar -->
+        <aside class="sidebar">
+            <div class="sidebar-header">
+                <h2><?php echo htmlspecialchars($tenantName); ?></h2>
+                <span class="role-badge"><?php echo htmlspecialchars($user['role'] ?? 'user'); ?></span>
+            </div>
+
+            <nav class="sidebar-nav">
+                <a href="/dashboard/" class="nav-item <?php echo ($currentPage ?? '') === 'overview' ? 'active' : ''; ?>">
+                    <span class="nav-icon">📊</span>
+                    <span>Übersicht</span>
+                </a>
+
+                <a href="/dashboard/stream.php" class="nav-item <?php echo ($currentPage ?? '') === 'stream' ? 'active' : ''; ?>">
+                    <span class="nav-icon">📹</span>
+                    <span>Stream</span>
+                </a>
+
+                <a href="/dashboard/branding.php" class="nav-item <?php echo ($currentPage ?? '') === 'branding' ? 'active' : ''; ?>">
+                    <span class="nav-icon">🎨</span>
+                    <span>Branding</span>
+                </a>
+
+                <a href="/dashboard/settings.php" class="nav-item <?php echo ($currentPage ?? '') === 'settings' ? 'active' : ''; ?>">
+                    <span class="nav-icon">⚙️</span>
+                    <span>Einstellungen</span>
+                </a>
+
+                <?php if ($settingsManager->isAnalyticsEnabled()): ?>
+                <a href="/dashboard/analytics.php" class="nav-item <?php echo ($currentPage ?? '') === 'analytics' ? 'active' : ''; ?>">
+                    <span class="nav-icon">📈</span>
+                    <span>Analytics</span>
+                </a>
+                <?php endif; ?>
+
+                <?php if ($settingsManager->isCustomDomainEnabled()): ?>
+                <a href="/dashboard/domains.php" class="nav-item <?php echo ($currentPage ?? '') === 'domains' ? 'active' : ''; ?>">
+                    <span class="nav-icon">🌐</span>
+                    <span>Domains</span>
+                </a>
+                <?php endif; ?>
+
+                <?php if ($settingsManager->isBillingEnabled()): ?>
+                <a href="/dashboard/billing.php" class="nav-item <?php echo ($currentPage ?? '') === 'billing' ? 'active' : ''; ?>">
+                    <span class="nav-icon">💳</span>
+                    <span>Abrechnung</span>
+                </a>
+                <?php endif; ?>
+
+                <?php if ($auth->isSuperAdmin()): ?>
+                <div class="nav-divider"></div>
+                <span class="nav-label">Admin</span>
+
+                <a href="/dashboard/admin/tenants.php" class="nav-item <?php echo ($currentPage ?? '') === 'admin-tenants' ? 'active' : ''; ?>">
+                    <span class="nav-icon">👥</span>
+                    <span>Kunden</span>
+                </a>
+
+                <a href="/dashboard/admin/plans.php" class="nav-item <?php echo ($currentPage ?? '') === 'admin-plans' ? 'active' : ''; ?>">
+                    <span class="nav-icon">📋</span>
+                    <span>Pläne</span>
+                </a>
+                <?php endif; ?>
+            </nav>
+
+            <div class="sidebar-footer">
+                <a href="/" class="nav-item" target="_blank">
+                    <span class="nav-icon">🔗</span>
+                    <span>Zur Livecam</span>
+                </a>
+                <a href="/dashboard/logout.php" class="nav-item logout">
+                    <span class="nav-icon">🚪</span>
+                    <span>Abmelden</span>
+                </a>
+            </div>
+        </aside>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <header class="main-header">
+                <h1><?php echo htmlspecialchars($pageTitle ?? 'Dashboard'); ?></h1>
+                <div class="header-actions">
+                    <span class="user-info">
+                        <?php echo htmlspecialchars($user['email'] ?? ''); ?>
+                    </span>
+                </div>
+            </header>
+
+            <div class="content-wrapper">
+                <?php if (isset($flashMessage)): ?>
+                <div class="alert alert-<?php echo $flashType ?? 'info'; ?>">
+                    <?php echo htmlspecialchars($flashMessage); ?>
+                </div>
+                <?php endif; ?>
+
+                <?php echo $content ?? ''; ?>
+            </div>
+        </main>
+    </div>
+
+    <script src="/dashboard/assets/dashboard.js"></script>
+</body>
+</html>

aurora-livecam/database/schema.sql

@@ -0,0 +1,205 @@
+-- Aurora Livecam - Multi-Tenant SaaS Schema
+-- Version: 1.0.0
+
+SET NAMES utf8mb4;
+SET FOREIGN_KEY_CHECKS = 0;
+
+-- --------------------------------------------------------
+-- Subscription Plans
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `plans` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `name` VARCHAR(100) NOT NULL,
+    `slug` VARCHAR(50) UNIQUE NOT NULL,
+    `stripe_price_id` VARCHAR(100) NULL,
+    `price_monthly` DECIMAL(10,2) DEFAULT 0.00,
+    `price_yearly` DECIMAL(10,2) DEFAULT 0.00,
+    `features` JSON NULL COMMENT '{"max_viewers": 100, "storage_gb": 5, "custom_domain": true}',
+    `is_active` TINYINT(1) DEFAULT 1,
+    `sort_order` INT DEFAULT 0,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- Default Plans
+INSERT INTO `plans` (`name`, `slug`, `price_monthly`, `price_yearly`, `features`, `sort_order`) VALUES
+('Free', 'free', 0.00, 0.00, '{"max_viewers": 10, "storage_gb": 0.5, "custom_domain": false, "weather_widget": true, "timelapse": false, "analytics": false, "branding": false}', 1),
+('Basic', 'basic', 19.00, 190.00, '{"max_viewers": 50, "storage_gb": 5, "custom_domain": false, "weather_widget": true, "timelapse": true, "analytics": true, "branding": false}', 2),
+('Professional', 'professional', 49.00, 490.00, '{"max_viewers": 200, "storage_gb": 20, "custom_domain": true, "weather_widget": true, "timelapse": true, "analytics": true, "branding": true}', 3),
+('Enterprise', 'enterprise', 149.00, 1490.00, '{"max_viewers": -1, "storage_gb": 100, "custom_domain": true, "weather_widget": true, "timelapse": true, "analytics": true, "branding": true, "priority_support": true}', 4);
+
+-- --------------------------------------------------------
+-- Tenants (Customers)
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `tenants` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `uuid` VARCHAR(36) UNIQUE NOT NULL,
+    `name` VARCHAR(255) NOT NULL,
+    `slug` VARCHAR(100) UNIQUE NOT NULL COMMENT 'URL-safe identifier, e.g. aurora, seecam',
+    `email` VARCHAR(255) NOT NULL,
+    `status` ENUM('trial', 'active', 'suspended', 'cancelled') DEFAULT 'trial',
+    `plan_id` INT UNSIGNED NULL,
+    `trial_ends_at` TIMESTAMP NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    FOREIGN KEY (`plan_id`) REFERENCES `plans`(`id`) ON DELETE SET NULL,
+    INDEX `idx_status` (`status`),
+    INDEX `idx_slug` (`slug`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Tenant Domains
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `tenant_domains` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NOT NULL,
+    `domain` VARCHAR(255) UNIQUE NOT NULL,
+    `is_primary` TINYINT(1) DEFAULT 0,
+    `ssl_status` ENUM('pending', 'active', 'failed') DEFAULT 'pending',
+    `verified_at` TIMESTAMP NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE,
+    INDEX `idx_domain` (`domain`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Tenant Settings (replaces settings.json per tenant)
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `tenant_settings` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NOT NULL,
+    `setting_key` VARCHAR(255) NOT NULL,
+    `setting_value` TEXT NULL,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    UNIQUE KEY `uk_tenant_key` (`tenant_id`, `setting_key`),
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Tenant Branding
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `tenant_branding` (
+    `tenant_id` INT UNSIGNED PRIMARY KEY,
+    `site_name` VARCHAR(255) NULL,
+    `site_name_full` VARCHAR(255) NULL,
+    `tagline` VARCHAR(255) NULL,
+    `logo_path` VARCHAR(500) NULL,
+    `favicon_path` VARCHAR(500) NULL,
+    `primary_color` VARCHAR(7) DEFAULT '#667eea',
+    `secondary_color` VARCHAR(7) DEFAULT '#764ba2',
+    `accent_color` VARCHAR(7) DEFAULT '#f093fb',
+    `welcome_text_de` TEXT NULL,
+    `welcome_text_en` TEXT NULL,
+    `footer_text` TEXT NULL,
+    `custom_css` TEXT NULL,
+    `custom_js` TEXT NULL,
+    `social_facebook` VARCHAR(255) NULL,
+    `social_instagram` VARCHAR(255) NULL,
+    `social_youtube` VARCHAR(255) NULL,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Tenant Streams
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `tenant_streams` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NOT NULL,
+    `name` VARCHAR(255) DEFAULT 'Main Stream',
+    `stream_url` VARCHAR(500) NOT NULL,
+    `stream_type` ENUM('hls', 'rtmp', 'webrtc', 'iframe') DEFAULT 'hls',
+    `is_active` TINYINT(1) DEFAULT 1,
+    `is_primary` TINYINT(1) DEFAULT 1,
+    `last_check_at` TIMESTAMP NULL,
+    `last_status` ENUM('online', 'offline', 'error') NULL,
+    `error_message` VARCHAR(500) NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Users
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `users` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NULL COMMENT 'NULL = Super Admin',
+    `email` VARCHAR(255) UNIQUE NOT NULL,
+    `password_hash` VARCHAR(255) NOT NULL,
+    `name` VARCHAR(255) NULL,
+    `role` ENUM('super_admin', 'tenant_admin', 'tenant_user') NOT NULL DEFAULT 'tenant_user',
+    `email_verified_at` TIMESTAMP NULL,
+    `last_login_at` TIMESTAMP NULL,
+    `remember_token` VARCHAR(100) NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE,
+    INDEX `idx_email` (`email`),
+    INDEX `idx_tenant` (`tenant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Subscriptions
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `subscriptions` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NOT NULL,
+    `plan_id` INT UNSIGNED NOT NULL,
+    `stripe_subscription_id` VARCHAR(100) NULL,
+    `stripe_customer_id` VARCHAR(100) NULL,
+    `status` ENUM('trialing', 'active', 'past_due', 'canceled', 'unpaid', 'incomplete') DEFAULT 'trialing',
+    `current_period_start` TIMESTAMP NULL,
+    `current_period_end` TIMESTAMP NULL,
+    `canceled_at` TIMESTAMP NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE,
+    FOREIGN KEY (`plan_id`) REFERENCES `plans`(`id`),
+    INDEX `idx_tenant` (`tenant_id`),
+    INDEX `idx_stripe_sub` (`stripe_subscription_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Invoices (Stripe cache)
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `invoices` (
+    `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NOT NULL,
+    `stripe_invoice_id` VARCHAR(100) UNIQUE NULL,
+    `amount` DECIMAL(10,2) NOT NULL,
+    `currency` VARCHAR(3) DEFAULT 'CHF',
+    `status` VARCHAR(50) NULL,
+    `paid_at` TIMESTAMP NULL,
+    `invoice_pdf_url` VARCHAR(500) NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Viewer Statistics
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `viewer_stats` (
+    `id` BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+    `tenant_id` INT UNSIGNED NOT NULL,
+    `recorded_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    `viewer_count` INT DEFAULT 0,
+    `unique_sessions` INT DEFAULT 0,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE,
+    INDEX `idx_tenant_time` (`tenant_id`, `recorded_at`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+-- --------------------------------------------------------
+-- Onboarding Progress
+-- --------------------------------------------------------
+CREATE TABLE IF NOT EXISTS `tenant_onboarding` (
+    `tenant_id` INT UNSIGNED PRIMARY KEY,
+    `current_step` INT DEFAULT 1,
+    `stream_verified` TINYINT(1) DEFAULT 0,
+    `branding_configured` TINYINT(1) DEFAULT 0,
+    `payment_configured` TINYINT(1) DEFAULT 0,
+    `completed_at` TIMESTAMP NULL,
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    FOREIGN KEY (`tenant_id`) REFERENCES `tenants`(`id`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+SET FOREIGN_KEY_CHECKS = 1;

aurora-livecam/indexmiau.php

@@ -0,0 +1,721 @@
+<?php
+use PHPMailer\PHPMailer\PHPMailer;
+use PHPMailer\PHPMailer\Exception;
+
+require __DIR__ . '/vendor/autoload.php';
+require_once 'SettingsManager.php';
+
+// SettingsManager initialisieren
+$settingsManager = new SettingsManager();
+
+// AJAX-Handler für Settings (MUSS ganz am Anfang sein!)
+if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['settings_action'])) {
+    header('Content-Type: application/json');
+
+    switch ($_POST['settings_action']) {
+        case 'get':
+            echo json_encode(['success' => true, 'settings' => $settingsManager->get()]);
+            exit;
+
+        case 'update':
+            $key = $_POST['key'] ?? null;
+            $value = $_POST['value'] ?? null;
+
+            if ($value === 'true') $value = true;
+            if ($value === 'false') $value = false;
+            if (is_numeric($value)) $value = intval($value);
+
+            if ($key && $settingsManager->set($key, $value)) {
+                echo json_encode(['success' => true, 'message' => 'Gespeichert']);
+            } else {
+                echo json_encode(['success' => false, 'message' => 'Fehler']);
+            }
+            exit;
+    }
+}
+
+if (isset($_GET['download_video'])) {
+    $videoDir = './videos/';
+    $latestVideo = null;
+    $latestTime = 0;
+    foreach (glob($videoDir . '*.mp4') as $video) {
+        $mtime = filemtime($video);
+        if ($mtime > $latestTime) { $latestTime = $mtime; $latestVideo = $video; }
+    }
+    if ($latestVideo) {
+        header('Content-Type: application/octet-stream');
+        header('Content-Disposition: attachment; filename="'.basename($latestVideo).'"');
+        header('Content-Length: ' . filesize($latestVideo));
+        readfile($latestVideo);
+        exit;
+    }
+    echo "Kein Video gefunden.";
+    exit;
+}
+
+$oldDomains = ['www.aurora-wetter-lifecam.ch', 'www.aurora-wetter-livecam.ch'];
+$newDomain = 'www.aurora-weather-livecam.com';
+if (in_array($_SERVER['HTTP_HOST'] ?? '', $oldDomains)) {
+    $protocol = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http';
+    header("HTTP/1.1 301 Moved Permanently");
+    header("Location: " . $protocol . '://' . $newDomain . $_SERVER['REQUEST_URI']);
+    exit;
+}
+
+session_start();
+error_reporting(E_ALL);
+ini_set('display_errors', 0);
+
+$imageDir = "./image";
+$imageFiles = glob("$imageDir/screenshot_*.jpg");
+if ($imageFiles) rsort($imageFiles);
+$imageFilesJson = json_encode($imageFiles ?: []);
+
+class ViewerCounter {
+    private $file = 'active_viewers.json';
+    private $timeout = 30;
+
+    public function handleHeartbeat() {
+        $ip = md5($_SERVER['REMOTE_ADDR'] . ($_SERVER['HTTP_USER_AGENT'] ?? ''));
+        $now = time();
+        $viewers = file_exists($this->file) ? json_decode(file_get_contents($this->file), true) ?? [] : [];
+        $viewers[$ip] = $now;
+        $active = [];
+        foreach ($viewers as $u => $t) { if ($now - $t < $this->timeout) $active[$u] = $t; }
+        file_put_contents($this->file, json_encode($active));
+        header('Content-Type: application/json');
+        echo json_encode(['count' => count($active)]);
+        exit;
+    }
+
+    public function getInitialCount() {
+        if (file_exists($this->file)) {
+            return max(1, count(json_decode(file_get_contents($this->file), true) ?? []));
+        }
+        return 1;
+    }
+}
+
+$viewerCounter = new ViewerCounter();
+
+class WebcamManager {
+    private $videoSrc = 'test_video.m3u8';
+
+    public function displayWebcam() {
+        return '<video id="webcam-player" autoplay muted playsinline></video>';
+    }
+
+    public function displayStreamStats() {
+        return '<div class="info-badge tech-stat" id="bitrate-display" style="display:none;">
+            <i class="fas fa-tachometer-alt"></i> <span id="bitrate-value">0.00</span> MBit/s
+        </div>';
+    }
+
+    public function getImageFiles() {
+        $f = glob("image/screenshot_*.jpg");
+        if ($f) rsort($f);
+        return json_encode($f ?: []);
+    }
+
+    public function getJavaScript() {
+        return "
+        document.addEventListener('DOMContentLoaded', function () {
+            var video = document.getElementById('webcam-player');
+            var videoSrc = '{$this->videoSrc}';
+            if(video && typeof Hls !== 'undefined' && Hls.isSupported()) {
+                var hls = new Hls();
+                hls.loadSource(videoSrc);
+                hls.attachMedia(video);
+                hls.on(Hls.Events.MANIFEST_PARSED, function () { video.play().catch(()=>{}); });
+            } else if (video) {
+                video.src = videoSrc;
+                video.play().catch(()=>{});
+            }
+        });";
+    }
+}
+
+class VisualCalendarManager {
+    private $videoDir, $settingsManager;
+    private $months = [1=>'Jan',2=>'Feb',3=>'Mär',4=>'Apr',5=>'Mai',6=>'Jun',7=>'Jul',8=>'Aug',9=>'Sep',10=>'Okt',11=>'Nov',12=>'Dez'];
+
+    public function __construct($videoDir = './videos/', $sm = null) {
+        $this->videoDir = $videoDir;
+        $this->settingsManager = $sm;
+    }
+
+    public function hasVideosForDate($y, $m, $d) {
+        return count(glob($this->videoDir . sprintf("daily_video_%04d%02d%02d_*.mp4", $y, $m, $d))) > 0;
+    }
+
+    public function getVideosForDate($y, $m, $d) {
+        $vids = [];
+        foreach (glob($this->videoDir . sprintf("daily_video_%04d%02d%02d_*.mp4", $y, $m, $d)) as $v) {
+            $vids[] = ['path' => $v, 'name' => basename($v), 'size' => filesize($v), 'time' => date('H:i', filemtime($v))];
+        }
+        return $vids;
+    }
+
+    public function displayVisualCalendar() {
+        $cy = isset($_GET['cal_year']) ? intval($_GET['cal_year']) : date('Y');
+        $cm = isset($_GET['cal_month']) ? intval($_GET['cal_month']) : date('n');
+        $sd = isset($_GET['cal_day']) ? intval($_GET['cal_day']) : null;
+        $pip = $this->settingsManager ? $this->settingsManager->get('video_mode.play_in_player') : true;
+        $dl = $this->settingsManager ? $this->settingsManager->get('video_mode.allow_download') : true;
+
+        $o = '<div class="calendar-box">';
+        $o .= '<div class="cal-nav"><button onclick="chgM('.$cy.','.($cm-1).')">&laquo;</button><span>'.$this->months[$cm].' '.$cy.'</span><button onclick="chgM('.$cy.','.($cm+1).')">&raquo;</button></div>';
+        $o .= '<div class="cal-grid">';
+        foreach(['Mo','Di','Mi','Do','Fr','Sa','So'] as $wd) $o .= '<div class="cal-hd">'.$wd.'</div>';
+
+        $fd = mktime(0,0,0,$cm,1,$cy);
+        $dim = date('t', $fd);
+        $dow = date('N', $fd) - 1;
+        for ($i=0; $i<$dow; $i++) $o .= '<div class="cal-day empty"></div>';
+
+        for ($d=1; $d<=$dim; $d++) {
+            $hv = $this->hasVideosForDate($cy,$cm,$d);
+            $sel = $sd==$d;
+            $td = ($cy==date('Y') && $cm==date('n') && $d==date('j'));
+            $cls = 'cal-day' . ($hv?' has-vid':'') . ($sel?' sel':'') . ($td?' today':'');
+            $o .= '<div class="'.$cls.'" onclick="selD('.$cy.','.$cm.','.$d.')"><span>'.$d.'</span>'.($hv?'<small>📹</small>':'').'</div>';
+        }
+        $o .= '</div>';
+
+        if ($sd) {
+            $vids = $this->getVideosForDate($cy,$cm,$sd);
+            $o .= '<div class="day-vids"><h4>📅 '.sprintf('%02d.%02d.%04d',$sd,$cm,$cy).'</h4>';
+            if ($vids) {
+                $o .= '<ul>';
+                foreach ($vids as $v) {
+                    $sz = round($v['size']/1024/1024,1);
+                    $tk = hash_hmac('sha256', $v['path'], session_id());
+                    $o .= '<li><span>🕐 '.$v['time'].'</span><span>'.$sz.' MB</span><span class="vid-btns">';
+                    if ($pip) $o .= '<a href="#" onclick="playVid(\''.htmlspecialchars($v['path']).'\');return false;" class="btn-play">▶️</a>';
+                    if ($dl) $o .= '<a href="?download_specific_video='.urlencode($v['path']).'&token='.$tk.'" class="btn-dl">⬇️</a>';
+                    $o .= '</span></li>';
+                }
+                $o .= '</ul>';
+            } else {
+                $o .= '<p>Keine Videos.</p>';
+            }
+            $o .= '</div>';
+        }
+        $o .= '</div>';
+        return $o;
+    }
+}
+
+class GuestbookManager {
+    private $entries = [], $file = 'guestbook.json';
+    public function __construct() { if (file_exists($this->file)) $this->entries = json_decode(file_get_contents($this->file), true) ?? []; }
+    public function handleFormSubmission() {
+        if (isset($_POST['guestbook'],$_POST['guest-name'],$_POST['guest-message'])) {
+            $this->entries[] = ['name'=>htmlspecialchars($_POST['guest-name']),'message'=>htmlspecialchars($_POST['guest-message']),'date'=>date('Y-m-d H:i:s')];
+            file_put_contents($this->file, json_encode($this->entries));
+        }
+    }
+    public function deleteEntry($i) { if (isset($this->entries[$i])) { unset($this->entries[$i]); $this->entries = array_values($this->entries); file_put_contents($this->file, json_encode($this->entries)); return true; } return false; }
+    public function displayForm() { return '<form method="post"><input type="hidden" name="guestbook" value="1"><label>Name:</label><input name="guest-name" required><label>Nachricht:</label><textarea name="guest-message" required></textarea><button type="submit">Senden</button></form>'; }
+    public function displayEntries($admin=false) {
+        $o = '<div class="gb-entries">';
+        foreach ($this->entries as $i=>$e) {
+            $o .= '<div class="gb-entry"><h4>'.$e['name'].'</h4><p>'.$e['message'].'</p><small>'.$e['date'].'</small>';
+            if ($admin) $o .= '<form method="post" style="display:inline"><input type="hidden" name="action" value="delete_guestbook"><input type="hidden" name="delete_entry" value="'.$i.'"><button class="del-btn">X</button></form>';
+            $o .= '</div>';
+        }
+        return $o.'</div>';
+    }
+}
+
+class ContactManager {
+    private $file = 'feedbacks.json';
+    public function displayForm() { return '<form method="post" id="contact-form"><input type="hidden" name="contact" value="1"><label>Name:</label><input name="name" required><label>E-Mail:</label><input type="email" name="email" required><label>Nachricht:</label><textarea name="message" required></textarea><button type="submit">Senden</button></form><div id="contact-fb"></div>'; }
+    public function handleSubmission($n,$e,$m) {
+        if (!$n||!$e||!$m) return ['success'=>false,'message'=>'Alle Felder ausfüllen'];
+        $fb = ['name'=>htmlspecialchars($n),'email'=>filter_var($e,FILTER_SANITIZE_EMAIL),'message'=>htmlspecialchars($m),'date'=>date('Y-m-d H:i:s'),'ip'=>$_SERVER['REMOTE_ADDR']??''];
+        $all = file_exists($this->file) ? json_decode(file_get_contents($this->file),true) : [];
+        $all[] = $fb;
+        file_put_contents($this->file, json_encode($all, JSON_PRETTY_PRINT));
+        return ['success'=>true,'message'=>'Nachricht gesendet!'];
+    }
+    public function deleteFeedback($i) { $all = json_decode(file_get_contents($this->file),true); if (isset($all[$i])) { unset($all[$i]); file_put_contents($this->file, json_encode(array_values($all),JSON_PRETTY_PRINT)); return true; } return false; }
+}
+
+class AdminManager {
+    public function isAdmin() { return isset($_SESSION['admin']) && $_SESSION['admin'] === true; }
+    public function handleLogin($u,$p) { if ($u==='admin' && $p==='sonne4000$$$$Q') { $_SESSION['admin']=true; return true; } return false; }
+    public function displayLoginForm() { return '<form method="post"><input type="hidden" name="admin-login" value="1"><label>User:</label><input name="username" required><label>Pass:</label><input type="password" name="password" required><button type="submit">Login</button></form>'; }
+    public function displayAdminContent() {
+        global $settingsManager;
+        $o = '<div class="admin-panel">';
+        $o .= '<h3>⚙️ Einstellungen</h3>';
+        $o .= '<div class="setting"><label>Zuschauer anzeigen</label><input type="checkbox" id="s-viewer" '.($settingsManager->get('viewer_display.enabled')?'checked':'').'></div>';
+        $o .= '<div class="setting"><label>Mindestanzahl</label><input type="number" id="s-min" value="'.$settingsManager->get('viewer_display.min_viewers').'" min="1" max="100"></div>';
+        $o .= '<div class="setting"><label>Im Player abspielen</label><input type="checkbox" id="s-play" '.($settingsManager->get('video_mode.play_in_player')?'checked':'').'></div>';
+        $o .= '<div class="setting"><label>Download erlauben</label><input type="checkbox" id="s-dl" '.($settingsManager->get('video_mode.allow_download')?'checked':'').'></div>';
+        $o .= '</div>';
+        $o .= '<div class="admin-panel"><h3>📩 Nachrichten</h3>';
+        $msgs = file_exists('feedbacks.json') ? json_decode(file_get_contents('feedbacks.json'),true) : [];
+        foreach ($msgs as $i=>$m) {
+            $o .= '<div class="msg"><strong>'.$m['name'].'</strong> ('.$m['email'].')<p>'.$m['message'].'</p><small>'.$m['date'].'</small>';
+            $o .= '<form method="post" style="display:inline"><input type="hidden" name="action" value="delete_feedback"><input type="hidden" name="delete_index" value="'.$i.'"><button class="del-btn">X</button></form></div>';
+        }
+        if (!$msgs) $o .= '<p>Keine Nachrichten.</p>';
+        $o .= '</div>';
+        return $o;
+    }
+    public function displayGalleryImages() {
+        $o = '<div class="gallery">';
+        foreach (glob("uploads/*.{jpg,jpeg,png,gif}",GLOB_BRACE) as $f) $o .= '<img src="'.$f.'" onclick="openImg(this.src)">';
+        return $o.'</div>';
+    }
+}
+
+class VideoArchiveManager {
+    private $dir;
+    public function __construct($d='./videos/') { $this->dir = $d; }
+    public function handleSpecificVideoDownload() {
+        if (isset($_GET['download_specific_video'],$_GET['token'])) {
+            $p = $_GET['download_specific_video'];
+            if (!hash_equals(hash_hmac('sha256',$p,session_id()), $_GET['token'])) { echo "Invalid"; exit; }
+            $rp = realpath($p);
+            $rd = realpath($this->dir);
+            if ($rp && strpos($rp,$rd)===0 && file_exists($rp)) {
+                header('Content-Type: video/mp4');
+                header('Content-Disposition: attachment; filename="'.basename($rp).'"');
+                header('Content-Length: '.filesize($rp));
+                readfile($rp);
+                exit;
+            }
+            echo "Not found"; exit;
+        }
+    }
+}
+
+$webcamManager = new WebcamManager();
+$guestbookManager = new GuestbookManager();
+$contactManager = new ContactManager();
+$adminManager = new AdminManager();
+$videoArchiveManager = new VideoArchiveManager('./videos/');
+$videoArchiveManager->handleSpecificVideoDownload();
+
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    if (isset($_POST['action']) && $_POST['action'] === 'viewer_heartbeat') $viewerCounter->handleHeartbeat();
+    if (isset($_POST['guestbook'])) { $guestbookManager->handleFormSubmission(); header("Location: ".$_SERVER['PHP_SELF']."#guestbook"); exit; }
+    if (isset($_POST['contact'])) {
+        $r = $contactManager->handleSubmission($_POST['name'],$_POST['email'],$_POST['message']);
+        if (isset($_SERVER['HTTP_X_REQUESTED_WITH'])) { header('Content-Type: application/json'); echo json_encode($r); exit; }
+        header('Location: '.$_SERVER['PHP_SELF'].'#kontakt'); exit;
+    }
+    if (isset($_POST['admin-login'])) { $adminManager->handleLogin($_POST['username'],$_POST['password']); header('Location: '.$_SERVER['PHP_SELF'].'#admin'); exit; }
+    if ($adminManager->isAdmin()) {
+        if (isset($_POST['action']) && $_POST['action']==='delete_guestbook') { $guestbookManager->deleteEntry(intval($_POST['delete_entry'])); header("Location: ".$_SERVER['PHP_SELF']."#guestbook"); exit; }
+        if (isset($_POST['action']) && $_POST['action']==='delete_feedback') { $contactManager->deleteFeedback(intval($_POST['delete_index'])); header("Location: ".$_SERVER['PHP_SELF']."#admin"); exit; }
+    }
+}
+
+$vc = $viewerCounter->getInitialCount();
+$sv = $settingsManager->get('viewer_display.enabled') && $vc >= $settingsManager->get('viewer_display.min_viewers');
+$mv = $settingsManager->get('viewer_display.min_viewers');
+?><!DOCTYPE html>
+<html lang="de">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=5,user-scalable=yes">
+<title>Aurora Livecam</title>
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">
+<script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:Arial,sans-serif;background:#f0f0f0;color:#333;line-height:1.6}
+.container{max-width:1100px;margin:0 auto;padding:0 15px}
+.section{padding:50px 0;background:#fff;margin-bottom:15px}
+.section h2{text-align:center;margin-bottom:25px;font-size:28px}
+
+header{background:#fff;padding:12px 0;position:sticky;top:0;z-index:100;box-shadow:0 2px 8px rgba(0,0,0,0.1)}
+.header-inner{display:flex;justify-content:space-between;align-items:center;flex-wrap:wrap;gap:10px}
+.logo img{height:45px}
+nav ul{list-style:none;display:flex;flex-wrap:wrap;gap:5px}
+nav a{text-decoration:none;color:#333;padding:8px 14px;border-radius:5px;font-weight:bold;transition:.3s}
+nav a:hover{background:#4CAF50;color:#fff}
+
+.hero{text-align:center;padding:40px 15px;background:linear-gradient(135deg,#667eea,#764ba2);color:#fff}
+.hero h1{font-size:2em;margin-bottom:10px}
+
+.video-box{max-width:900px;margin:0 auto 20px}
+.video-wrap{position:relative;padding-bottom:56.25%;background:#000;border-radius:10px;overflow:hidden}
+.video-wrap video,.video-wrap img,.video-wrap #dvp{position:absolute;top:0;left:0;width:100%;height:100%;object-fit:contain}
+#tlv,#dvp{display:none;background:#000}
+#dvp video{width:100%;height:100%}
+
+.zoom-btns{position:absolute;bottom:15px;right:15px;display:flex;gap:8px;z-index:100}
+.zoom-btns button{width:44px;height:44px;border:none;border-radius:50%;background:rgba(255,255,255,.95);font-size:20px;cursor:pointer;box-shadow:0 2px 8px rgba(0,0,0,.3);transition:.2s}
+.zoom-btns button:hover{transform:scale(1.1);background:#fff}
+
+.info-bar{display:flex;justify-content:center;gap:15px;margin:15px 0;flex-wrap:wrap}
+.badge{background:#fff;padding:8px 18px;border-radius:25px;font-weight:bold;display:flex;align-items:center;gap:8px;box-shadow:0 2px 8px rgba(0,0,0,.1)}
+.badge.live{background:#fff5f5;color:#d32f2f}
+.dot{width:8px;height:8px;background:#f44;border-radius:50%;animation:pulse 2s infinite}
+@keyframes pulse{0%,100%{box-shadow:0 0 0 0 rgba(244,67,54,.6)}50%{box-shadow:0 0 0 8px transparent}}
+
+.btns{display:flex;justify-content:center;gap:10px;flex-wrap:wrap;margin:15px 0}
+.btn{padding:10px 20px;background:linear-gradient(135deg,#4CAF50,#45a049);color:#fff;border:none;border-radius:6px;font-weight:bold;cursor:pointer;text-decoration:none;transition:.3s}
+.btn:hover{transform:translateY(-2px);box-shadow:0 4px 12px rgba(76,175,80,.4)}
+.btn.purple{background:linear-gradient(135deg,#667eea,#764ba2)}
+
+#tl-ctrl{display:none;background:#fff;padding:12px 20px;border-radius:30px;margin:15px auto;max-width:700px;box-shadow:0 3px 10px rgba(0,0,0,.1)}
+.tl-bar{display:flex;align-items:center;gap:12px;flex-wrap:wrap;justify-content:center}
+.tl-btn{width:40px;height:40px;border:none;border-radius:50%;background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;cursor:pointer;font-size:14px}
+.tl-btn.on{background:linear-gradient(135deg,#4CAF50,#45a049)}
+.tl-btn.wide{width:auto;padding:0 15px;border-radius:20px}
+#tl-slider{flex:1;min-width:120px;max-width:250px}
+#tl-time{font-family:monospace;background:#f5f5f5;padding:6px 12px;border-radius:15px}
+
+#back-live{display:none}
+
+.calendar-box{max-width:700px;margin:0 auto;background:#fff;border-radius:10px;padding:20px;box-shadow:0 3px 15px rgba(0,0,0,.1)}
+.cal-nav{display:flex;justify-content:space-between;align-items:center;background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;padding:12px 15px;border-radius:8px;margin-bottom:15px}
+.cal-nav button{background:rgba(255,255,255,.2);border:none;color:#fff;padding:8px 15px;border-radius:5px;font-size:18px;cursor:pointer}
+.cal-grid{display:grid;grid-template-columns:repeat(7,1fr);gap:5px}
+.cal-hd{text-align:center;font-weight:bold;padding:8px;background:#f5f5f5;border-radius:4px;font-size:12px}
+.cal-day{aspect-ratio:1;display:flex;flex-direction:column;align-items:center;justify-content:center;background:#fff;border:2px solid #e0e0e0;border-radius:8px;cursor:pointer;transition:.2s;position:relative;font-size:14px}
+.cal-day:hover:not(.empty){transform:scale(1.05);border-color:#667eea}
+.cal-day.empty{background:transparent;border:none;cursor:default}
+.cal-day.has-vid{background:linear-gradient(135deg,#e3f2fd,#bbdefb);border-color:#2196F3}
+.cal-day.sel{background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;transform:scale(1.08)}
+.cal-day.today{border:2px solid #4CAF50}
+.cal-day small{position:absolute;bottom:2px;right:2px;font-size:10px}
+
+.day-vids{background:#f9f9f9;border-radius:8px;padding:15px;margin-top:15px}
+.day-vids h4{margin-bottom:10px;border-bottom:2px solid #667eea;padding-bottom:8px}
+.day-vids ul{list-style:none}
+.day-vids li{display:flex;justify-content:space-between;align-items:center;padding:10px;background:#fff;margin-bottom:8px;border-radius:6px;flex-wrap:wrap;gap:8px}
+.vid-btns{display:flex;gap:8px}
+.btn-play,.btn-dl{padding:6px 12px;border-radius:15px;text-decoration:none;color:#fff;font-size:13px}
+.btn-play{background:linear-gradient(135deg,#667eea,#764ba2)}
+.btn-dl{background:linear-gradient(135deg,#4CAF50,#45a049)}
+
+form{display:grid;gap:12px;background:#f9f9f9;padding:20px;border-radius:8px;max-width:500px;margin:0 auto}
+input,textarea{width:100%;padding:10px;border:2px solid #ddd;border-radius:6px;font-size:15px}
+input:focus,textarea:focus{border-color:#667eea;outline:none}
+button[type=submit]{padding:10px 20px;background:linear-gradient(135deg,#4CAF50,#45a049);color:#fff;border:none;border-radius:6px;font-weight:bold;cursor:pointer}
+
+.gb-entries{max-width:600px;margin:20px auto 0}
+.gb-entry{background:#fff;border-left:4px solid #4CAF50;padding:15px;margin-bottom:10px;border-radius:6px;box-shadow:0 2px 6px rgba(0,0,0,.08)}
+.gb-entry h4{margin-bottom:5px}
+.gb-entry small{color:#888}
+
+.gallery{display:flex;gap:10px;overflow-x:auto;padding:10px 0}
+.gallery img{width:200px;height:140px;object-fit:cover;border-radius:8px;cursor:pointer;flex-shrink:0}
+
+.admin-panel{background:#fff;padding:20px;border-radius:10px;margin-bottom:20px}
+.admin-panel h3{margin-bottom:15px;border-bottom:2px solid #667eea;padding-bottom:8px}
+.setting{display:flex;justify-content:space-between;align-items:center;padding:10px 0;border-bottom:1px solid #eee}
+.setting:last-child{border-bottom:none}
+.setting input[type=checkbox]{width:20px;height:20px}
+.setting input[type=number]{width:60px;padding:5px;text-align:center}
+.msg{background:#f9f9f9;padding:12px;border-left:3px solid #667eea;margin-bottom:8px;border-radius:4px}
+.del-btn{background:#f44;color:#fff;border:none;padding:4px 10px;border-radius:4px;cursor:pointer}
+
+footer{background:#333;color:#fff;padding:30px 0;text-align:center}
+footer a{color:#fff;margin:0 10px}
+
+.modal{display:none;position:fixed;z-index:1000;left:0;top:0;width:100%;height:100%;background:rgba(0,0,0,.9);align-items:center;justify-content:center}
+.modal img{max-width:95%;max-height:90%}
+.modal .close{position:absolute;top:15px;right:25px;color:#fff;font-size:35px;cursor:pointer}
+
+@media(max-width:600px){
+.header-inner{flex-direction:column}
+nav ul{justify-content:center}
+.hero h1{font-size:1.5em}
+.btns{flex-direction:column}
+.btn{width:100%}
+.tl-bar{flex-direction:column}
+#tl-slider{width:100%;max-width:none}
+}
+</style>
+</head>
+<body>
+
+<header>
+<div class="container header-inner">
+<div class="logo"><img src="logo.png" alt="Logo"></div>
+<nav><ul>
+<li><a href="#cam">Webcam</a></li>
+<li><a href="#archive">Archiv</a></li>
+<li><a href="#guestbook">Gästebuch</a></li>
+<li><a href="#kontakt">Kontakt</a></li>
+<?php if($adminManager->isAdmin()): ?><li><a href="#admin">Admin</a></li><?php endif; ?>
+</ul></nav>
+</div>
+</header>
+
+<section class="hero">
+<h1>Aurora Wetter Livecam</h1>
+<p>Faszinierende Ausblicke aus dem Zürcher Oberland</p>
+</section>
+
+<section id="cam" class="section">
+<div class="container">
+<div class="video-box">
+<div class="video-wrap" id="vw">
+<?php echo $webcamManager->displayWebcam(); ?>
+<div id="tlv"><img id="tl-img"><div id="tl-overlay" style="position:absolute;top:10px;left:10px;background:rgba(0,0,0,.7);color:#fff;padding:6px 12px;border-radius:4px;font-family:monospace"></div></div>
+<div id="dvp"><video id="dv" controls playsinline></video></div>
+<div class="zoom-btns">
+<button onclick="zoom(-1)">−</button>
+<button onclick="zoom(0)">⟲</button>
+<button onclick="zoom(1)">+</button>
+</div>
+</div>
+</div>
+
+<div id="tl-ctrl">
+<div class="tl-bar">
+<button class="tl-btn" id="tl-play"><i class="fas fa-play"></i></button>
+<button class="tl-btn" id="tl-rev"><i class="fas fa-backward"></i></button>
+<input type="range" id="tl-slider" min="0" value="0">
+<span id="tl-time">--:--:--</span>
+<button class="tl-btn wide" id="tl-spd">1x</button>
+<button class="tl-btn wide on" id="tl-back"><i class="fas fa-video"></i> Live</button>
+</div>
+</div>
+
+<button class="btn purple" id="back-live" onclick="toLive()"><i class="fas fa-video"></i> Zurück zu Live</button>
+
+<div class="info-bar">
+<?php echo $webcamManager->displayStreamStats(); ?>
+<?php if($sv): ?><div class="badge live"><span class="dot"></span><strong id="vc"><?php echo $vc; ?></strong> Zuschauer</div><?php endif; ?>
+</div>
+
+<div class="btns">
+<a href="?action=snapshot" class="btn">📷 Snapshot</a>
+<button class="btn" id="tl-btn">🎬 Zeitraffer</button>
+<a href="?download_video=1" class="btn">⬇️ Tagesvideo</a>
+</div>
+</div>
+</section>
+
+<section id="archive" class="section">
+<div class="container">
+<h2>📅 Videoarchiv</h2>
+<?php $cal = new VisualCalendarManager('./videos/', $settingsManager); echo $cal->displayVisualCalendar(); ?>
+</div>
+</section>
+
+<section id="guestbook" class="section">
+<div class="container">
+<h2>Gästebuch</h2>
+<?php echo $guestbookManager->displayForm(); echo $guestbookManager->displayEntries($adminManager->isAdmin()); ?>
+</div>
+</section>
+
+<section id="kontakt" class="section">
+<div class="container">
+<h2>Kontakt</h2>
+<?php echo $contactManager->displayForm(); ?>
+</div>
+</section>
+
+<section id="gallery" class="section">
+<div class="container">
+<h2>Galerie</h2>
+<?php echo $adminManager->displayGalleryImages(); ?>
+</div>
+</section>
+
+<?php if($adminManager->isAdmin()): ?>
+<section id="admin" class="section">
+<div class="container">
+<h2>⚙️ Admin</h2>
+<?php echo $adminManager->displayAdminContent(); ?>
+</div>
+</section>
+<?php else: ?>
+<section id="admin" class="section">
+<div class="container">
+<h2>Admin Login</h2>
+<?php echo $adminManager->displayLoginForm(); ?>
+</div>
+</section>
+<?php endif; ?>
+
+<footer>
+<a href="#cam">Webcam</a>
+<a href="#archive">Archiv</a>
+<a href="#kontakt">Kontakt</a>
+<p style="margin-top:15px">&copy; 2024 Aurora Livecam</p>
+</footer>
+
+<div class="modal" id="modal" onclick="this.style.display='none'">
+<span class="close">&times;</span>
+<img id="modal-img">
+</div>
+
+<script>
+<?php echo $webcamManager->getJavaScript(); ?>
+
+let zoomLvl=1;
+function zoom(d){
+if(d===0) zoomLvl=1;
+else zoomLvl=Math.max(1,Math.min(4,zoomLvl+d*0.5));
+// Alle Video-Elemente in allen Modi
+const targets=['#webcam-player','#tl-img','#dv'];
+targets.forEach(sel=>{
+const el=document.querySelector(sel);
+if(el){
+el.style.transform='scale('+zoomLvl+')';
+el.style.transformOrigin='center center';
+el.style.transition='transform 0.2s ease';
+}
+});
+// Zoom-Level Anzeige
+showZoomLevel();
+}
+function showZoomLevel(){
+let ind=document.getElementById('zoom-ind');
+if(!ind){
+ind=document.createElement('div');
+ind.id='zoom-ind';
+ind.style.cssText='position:absolute;top:15px;left:15px;background:rgba(0,0,0,0.7);color:#fff;padding:8px 14px;border-radius:20px;font-weight:bold;z-index:100;transition:opacity 0.3s';
+document.getElementById('vw').appendChild(ind);
+}
+ind.textContent='🔍 '+Math.round(zoomLvl*100)+'%';
+ind.style.opacity='1';
+clearTimeout(ind.hideTimer);
+ind.hideTimer=setTimeout(()=>{ind.style.opacity='0';},1500);
+}
+
+const TL={
+imgs:<?php echo $imageFilesJson; ?>,
+idx:0,playing:false,rev:false,spd:1,spds:[1,10,100],iv:null,
+init(){
+document.getElementById('tl-play').onclick=()=>this.toggle();
+document.getElementById('tl-rev').onclick=()=>this.toggleRev();
+document.getElementById('tl-spd').onclick=()=>this.cycleSpd();
+document.getElementById('tl-back').onclick=()=>toLive();
+document.getElementById('tl-slider').max=this.imgs.length-1;
+document.getElementById('tl-slider').oninput=e=>this.seek(+e.target.value);
+},
+show(){
+document.getElementById('webcam-player').style.display='none';
+document.getElementById('dvp').style.display='none';
+document.getElementById('tlv').style.display='block';
+document.getElementById('tl-ctrl').style.display='block';
+document.getElementById('back-live').style.display='none';
+this.idx=0;this.frame();
+},
+toggle(){
+this.playing=!this.playing;
+document.getElementById('tl-play').innerHTML=this.playing?'<i class="fas fa-pause"></i>':'<i class="fas fa-play"></i>';
+if(this.playing)this.play();else this.stop();
+},
+toggleRev(){this.rev=!this.rev;document.getElementById('tl-rev').classList.toggle('on',this.rev);},
+cycleSpd(){const i=this.spds.indexOf(this.spd);this.spd=this.spds[(i+1)%this.spds.length];document.getElementById('tl-spd').textContent=this.spd+'x';if(this.playing){this.stop();this.play();}},
+play(){this.iv=setInterval(()=>this.next(),200/this.spd);},
+stop(){clearInterval(this.iv);},
+next(){this.idx+=this.rev?-1:1;if(this.idx<0)this.idx=this.imgs.length-1;if(this.idx>=this.imgs.length)this.idx=0;this.frame();},
+seek(i){this.idx=i;this.frame();},
+frame(){
+const img=this.imgs[this.idx];if(!img)return;
+document.getElementById('tl-img').src=img;
+document.getElementById('tl-slider').value=this.idx;
+const m=img.match(/(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})/);
+if(m){const t=m[3]+'.'+m[2]+'.'+m[1]+' '+m[4]+':'+m[5]+':'+m[6];document.getElementById('tl-time').textContent=t;document.getElementById('tl-overlay').textContent=t;}
+}
+};
+
+function playVid(p){
+document.getElementById('webcam-player').style.display='none';
+document.getElementById('tlv').style.display='none';
+document.getElementById('tl-ctrl').style.display='none';
+document.getElementById('dvp').style.display='block';
+document.getElementById('back-live').style.display='block';
+const v=document.getElementById('dv');v.src=p;v.play();
+document.getElementById('cam').scrollIntoView({behavior:'smooth'});
+}
+
+function toLive(){
+TL.stop();TL.playing=false;
+document.getElementById('tl-play').innerHTML='<i class="fas fa-play"></i>';
+document.getElementById('tlv').style.display='none';
+document.getElementById('tl-ctrl').style.display='none';
+document.getElementById('dvp').style.display='none';
+document.getElementById('back-live').style.display='none';
+document.getElementById('webcam-player').style.display='block';
+document.getElementById('tl-btn').textContent='🎬 Zeitraffer';
+document.getElementById('dv').pause();document.getElementById('dv').src='';
+zoomLvl=1;zoom(0);
+}
+
+function chgM(y,m){if(m<1){m=12;y--;}if(m>12){m=1;y++;}location.href='?cal_year='+y+'&cal_month='+m+'#archive';}
+function selD(y,m,d){location.href='?cal_year='+y+'&cal_month='+m+'&cal_day='+d+'#archive';}
+
+function openImg(s){document.getElementById('modal-img').src=s;document.getElementById('modal').style.display='flex';}
+
+function updV(){
+fetch(location.href,{method:'POST',body:new URLSearchParams({action:'viewer_heartbeat'})})
+.then(r=>r.json()).then(d=>{const e=document.getElementById('vc');if(e&&d.count)e.textContent=d.count;});
+}
+
+<?php if($adminManager->isAdmin()): ?>
+function saveSetting(key, value) {
+const formData = new FormData();
+formData.append('settings_action', 'update');
+formData.append('key', key);
+formData.append('value', value);
+
+fetch(window.location.pathname, {
+method: 'POST',
+body: formData
+})
+.then(r => r.json())
+.then(data => {
+const toast = document.createElement('div');
+toast.innerHTML = data.success ? '✓ Gespeichert' : '✗ Fehler: ' + (data.message || '');
+toast.style.cssText = 'position:fixed;top:20px;right:20px;padding:15px 25px;border-radius:8px;background:' +
+(data.success ? '#4CAF50' : '#f44336') + ';color:#fff;font-weight:bold;z-index:9999;box-shadow:0 4px 12px rgba(0,0,0,0.3);';
+document.body.appendChild(toast);
+setTimeout(() => { toast.style.opacity = '0'; toast.style.transition = 'opacity 0.3s'; }, 1500);
+setTimeout(() => toast.remove(), 2000);
+})
+.catch(err => {
+console.error('Settings save error:', err);
+alert('Fehler beim Speichern: ' + err.message);
+});
+}
+
+// Settings Event-Handler nach DOM-Load binden
+document.addEventListener('DOMContentLoaded', function() {
+const sViewer = document.getElementById('s-viewer');
+const sMin = document.getElementById('s-min');
+const sPlay = document.getElementById('s-play');
+const sDl = document.getElementById('s-dl');
+
+if (sViewer) sViewer.addEventListener('change', function() {
+saveSetting('viewer_display.enabled', this.checked ? 'true' : 'false');
+});
+if (sMin) sMin.addEventListener('change', function() {
+saveSetting('viewer_display.min_viewers', this.value);
+});
+if (sPlay) sPlay.addEventListener('change', function() {
+saveSetting('video_mode.play_in_player', this.checked ? 'true' : 'false');
+});
+if (sDl) sDl.addEventListener('change', function() {
+saveSetting('video_mode.allow_download', this.checked ? 'true' : 'false');
+});
+});
+<?php endif; ?>
+
+document.addEventListener('DOMContentLoaded',()=>{
+TL.init();
+document.getElementById('tl-btn').onclick=()=>{
+if(document.getElementById('tlv').style.display==='block'){toLive();}
+else{TL.show();document.getElementById('tl-btn').textContent='↩️ Zurück zu Live';}
+};
+setTimeout(updV,2000);setInterval(updV,10000);
+});
+</script>
+</body>
+</html>

aurora-livecam/js/admin-settings.js

@@ -0,0 +1,140 @@
+/**
+ * Admin Settings Manager - AJAX ohne Reload
+ */
+const AdminSettings = {
+    settings: {},
+
+    init: function() {
+        this.loadSettings();
+        this.setupEventListeners();
+    },
+
+    loadSettings: function() {
+        fetch(window.location.href, {
+            method: 'POST',
+            headers: {'Content-Type': 'application/x-www-form-urlencoded'},
+            body: 'settings_action=get'
+        })
+        .then(r => r.json())
+        .then(data => {
+            if (data.success) {
+                this.settings = data.settings;
+                this.updateUI();
+            }
+        })
+        .catch(err => console.error('Settings load error:', err));
+    },
+
+    updateSetting: function(key, value) {
+        fetch(window.location.href, {
+            method: 'POST',
+            headers: {'Content-Type': 'application/x-www-form-urlencoded'},
+            body: `settings_action=update&key=${encodeURIComponent(key)}&value=${encodeURIComponent(value)}`
+        })
+        .then(r => r.json())
+        .then(data => {
+            if (data.success) {
+                this.showNotification('✓ Einstellung gespeichert', 'success');
+                // Sofort UI aktualisieren
+                this.applySettingImmediately(key, value);
+            } else {
+                this.showNotification('✗ Fehler beim Speichern', 'error');
+            }
+        })
+        .catch(err => {
+            console.error('Settings update error:', err);
+            this.showNotification('✗ Netzwerkfehler', 'error');
+        });
+    },
+
+    applySettingImmediately: function(key, value) {
+        // Sofortige Anwendung ohne Reload
+        switch(key) {
+            case 'viewer_display.enabled':
+                const viewerEl = document.querySelector('.viewer-stat');
+                if (viewerEl) {
+                    viewerEl.style.display = value === true || value === 'true' ? 'inline-flex' : 'none';
+                }
+                break;
+
+            case 'viewer_display.min_viewers':
+                // Wird beim nächsten Heartbeat angewendet
+                window.minViewersToShow = parseInt(value);
+                break;
+        }
+    },
+
+    updateUI: function() {
+        // Checkbox für Zuschauer-Anzeige
+        const viewerEnabled = document.getElementById('setting-viewer-enabled');
+        if (viewerEnabled) {
+            viewerEnabled.checked = this.settings.viewer_display?.enabled ?? true;
+        }
+
+        // Mindestanzahl
+        const minViewers = document.getElementById('setting-min-viewers');
+        if (minViewers) {
+            minViewers.value = this.settings.viewer_display?.min_viewers ?? 1;
+        }
+
+        // Video-Modus
+        const playInPlayer = document.getElementById('setting-play-in-player');
+        if (playInPlayer) {
+            playInPlayer.checked = this.settings.video_mode?.play_in_player ?? true;
+        }
+
+        const allowDownload = document.getElementById('setting-allow-download');
+        if (allowDownload) {
+            allowDownload.checked = this.settings.video_mode?.allow_download ?? true;
+        }
+    },
+
+    setupEventListeners: function() {
+        // Zuschauer-Anzeige Toggle
+        document.getElementById('setting-viewer-enabled')?.addEventListener('change', (e) => {
+            this.updateSetting('viewer_display.enabled', e.target.checked);
+        });
+
+        // Mindestanzahl Zuschauer
+        document.getElementById('setting-min-viewers')?.addEventListener('change', (e) => {
+            this.updateSetting('viewer_display.min_viewers', e.target.value);
+        });
+
+        // Video im Player abspielen
+        document.getElementById('setting-play-in-player')?.addEventListener('change', (e) => {
+            this.updateSetting('video_mode.play_in_player', e.target.checked);
+        });
+
+        // Download erlauben
+        document.getElementById('setting-allow-download')?.addEventListener('change', (e) => {
+            this.updateSetting('video_mode.allow_download', e.target.checked);
+        });
+    },
+
+    showNotification: function(message, type) {
+        const notification = document.createElement('div');
+        notification.className = `admin-notification ${type}`;
+        notification.textContent = message;
+        notification.style.cssText = `
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            padding: 15px 25px;
+            border-radius: 8px;
+            background: ${type === 'success' ? '#4CAF50' : '#f44336'};
+            color: white;
+            font-weight: bold;
+            z-index: 10000;
+            animation: slideIn 0.3s ease;
+        `;
+        document.body.appendChild(notification);
+        setTimeout(() => notification.remove(), 3000);
+    }
+};
+
+// Initialisierung nur im Admin-Bereich
+document.addEventListener('DOMContentLoaded', function() {
+    if (document.getElementById('admin-settings-panel')) {
+        AdminSettings.init();
+    }
+});

aurora-livecam/js/timelapse-controls.js

@@ -0,0 +1,167 @@
+/**
+ * Timelapse Controller mit Slider, Geschwindigkeit und Rückwärts
+ */
+const TimelapseController = {
+    imageFiles: [],
+    currentIndex: 0,
+    isPlaying: false,
+    isReverse: false,
+    speed: 1,
+    availableSpeeds: [1, 10, 100],
+    intervalId: null,
+    baseInterval: 200, // ms bei 1x
+
+    init: function(imageFilesArray) {
+        this.imageFiles = imageFilesArray;
+        this.setupControls();
+        this.updateSlider();
+    },
+
+    setupControls: function() {
+        const container = document.getElementById('timelapse-controls');
+        if (!container) return;
+
+        container.innerHTML = `
+            <div class="timelapse-control-bar">
+                <button id="tl-play-pause" class="tl-btn" title="Play/Pause">
+                    <i class="fas fa-play"></i>
+                </button>
+                <button id="tl-reverse" class="tl-btn" title="Rückwärts">
+                    <i class="fas fa-backward"></i>
+                </button>
+                <div class="tl-slider-container">
+                    <input type="range" id="tl-slider" min="0" max="100" value="0">
+                    <span id="tl-time-display">00:00:00</span>
+                </div>
+                <div class="tl-speed-container">
+                    <button id="tl-speed" class="tl-btn tl-speed-btn">1x</button>
+                </div>
+                <button id="tl-back-live" class="tl-btn tl-back-btn" title="Zurück zu Live">
+                    <i class="fas fa-video"></i> Live
+                </button>
+            </div>
+        `;
+
+        // Event Listeners
+        document.getElementById('tl-play-pause').onclick = () => this.togglePlay();
+        document.getElementById('tl-reverse').onclick = () => this.toggleReverse();
+        document.getElementById('tl-speed').onclick = () => this.cycleSpeed();
+        document.getElementById('tl-back-live').onclick = () => this.backToLive();
+
+        const slider = document.getElementById('tl-slider');
+        slider.max = this.imageFiles.length - 1;
+        slider.oninput = (e) => this.seekTo(parseInt(e.target.value));
+    },
+
+    togglePlay: function() {
+        this.isPlaying = !this.isPlaying;
+        const btn = document.getElementById('tl-play-pause');
+        btn.innerHTML = this.isPlaying ? '<i class="fas fa-pause"></i>' : '<i class="fas fa-play"></i>';
+
+        if (this.isPlaying) {
+            this.startPlayback();
+        } else {
+            this.stopPlayback();
+        }
+    },
+
+    toggleReverse: function() {
+        this.isReverse = !this.isReverse;
+        const btn = document.getElementById('tl-reverse');
+        btn.classList.toggle('active', this.isReverse);
+        btn.innerHTML = this.isReverse ?
+            '<i class="fas fa-forward"></i>' :
+            '<i class="fas fa-backward"></i>';
+    },
+
+    cycleSpeed: function() {
+        const idx = this.availableSpeeds.indexOf(this.speed);
+        this.speed = this.availableSpeeds[(idx + 1) % this.availableSpeeds.length];
+        document.getElementById('tl-speed').textContent = this.speed + 'x';
+
+        if (this.isPlaying) {
+            this.stopPlayback();
+            this.startPlayback();
+        }
+    },
+
+    startPlayback: function() {
+        const interval = this.baseInterval / this.speed;
+        this.intervalId = setInterval(() => this.nextFrame(), interval);
+    },
+
+    stopPlayback: function() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    },
+
+    nextFrame: function() {
+        if (this.isReverse) {
+            this.currentIndex--;
+            if (this.currentIndex < 0) this.currentIndex = this.imageFiles.length - 1;
+        } else {
+            this.currentIndex++;
+            if (this.currentIndex >= this.imageFiles.length) this.currentIndex = 0;
+        }
+        this.showFrame(this.currentIndex);
+    },
+
+    seekTo: function(index) {
+        this.currentIndex = index;
+        this.showFrame(index);
+    },
+
+    showFrame: function(index) {
+        const img = document.getElementById('timelapse-image');
+        if (img && this.imageFiles[index]) {
+            img.src = this.imageFiles[index];
+        }
+        this.updateSlider();
+        this.updateTimeDisplay();
+    },
+
+    updateSlider: function() {
+        const slider = document.getElementById('tl-slider');
+        if (slider) slider.value = this.currentIndex;
+    },
+
+    updateTimeDisplay: function() {
+        const display = document.getElementById('tl-time-display');
+        if (!display || !this.imageFiles[this.currentIndex]) return;
+
+        const filename = this.imageFiles[this.currentIndex];
+        const match = filename.match(/(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})/);
+        if (match) {
+            const [_, y, m, d, h, min, s] = match;
+            display.textContent = `${d}.${m}.${y} ${h}:${min}:${s}`;
+        }
+    },
+
+    backToLive: function() {
+        this.stopPlayback();
+        this.isPlaying = false;
+
+        // Live-Video wieder anzeigen
+        document.getElementById('timelapse-viewer').style.display = 'none';
+        document.getElementById('webcam-player').style.display = 'block';
+        document.getElementById('timelapse-button').textContent = 'Wochenzeitraffer';
+
+        // Controls verstecken
+        const controls = document.getElementById('timelapse-controls');
+        if (controls) controls.style.display = 'none';
+    },
+
+    show: function() {
+        document.getElementById('timelapse-viewer').style.display = 'block';
+        document.getElementById('webcam-player').style.display = 'none';
+        document.getElementById('daily-video-player').style.display = 'none';
+
+        const controls = document.getElementById('timelapse-controls');
+        if (controls) controls.style.display = 'block';
+
+        this.currentIndex = 0;
+        this.showFrame(0);
+    }
+};

aurora-livecam/js/video-player.js

@@ -0,0 +1,108 @@
+/**
+ * Daily Video Player - Spielt Tagesvideos im Hauptfenster ab
+ */
+const DailyVideoPlayer = {
+    currentVideo: null,
+    videoElement: null,
+
+    init: function() {
+        this.createPlayerElement();
+        this.setupEventListeners();
+    },
+
+    createPlayerElement: function() {
+        // Player-Container erstellen falls nicht vorhanden
+        if (document.getElementById('daily-video-player')) return;
+
+        const container = document.createElement('div');
+        container.id = 'daily-video-player';
+        container.style.display = 'none';
+        container.innerHTML = `
+            <video id="daily-video" controls playsinline>
+                <source src="" type="video/mp4">
+            </video>
+            <div class="video-player-controls">
+                <button id="dvp-back-live" class="tl-btn tl-back-btn">
+                    <i class="fas fa-video"></i> Zurück zu Live
+                </button>
+                <a id="dvp-download" class="button" style="display:none;">
+                    <i class="fas fa-download"></i> Download
+                </a>
+            </div>
+        `;
+
+        // Nach dem Webcam-Player einfügen
+        const videoContainer = document.querySelector('.video-container');
+        if (videoContainer) {
+            videoContainer.appendChild(container);
+        }
+
+        this.videoElement = document.getElementById('daily-video');
+    },
+
+    setupEventListeners: function() {
+        document.getElementById('dvp-back-live')?.addEventListener('click', () => this.backToLive());
+
+        // Video-Ende Event
+        this.videoElement?.addEventListener('ended', () => {
+            // Optional: Automatisch zurück zu Live
+        });
+    },
+
+    playVideo: function(videoPath, allowDownload = true) {
+        this.currentVideo = videoPath;
+
+        // Andere Player verstecken
+        document.getElementById('webcam-player').style.display = 'none';
+        document.getElementById('timelapse-viewer').style.display = 'none';
+        document.getElementById('timelapse-controls')?.style.display = 'none';
+
+        // Diesen Player anzeigen
+        const player = document.getElementById('daily-video-player');
+        player.style.display = 'block';
+
+        // Video laden
+        this.videoElement.src = videoPath;
+        this.videoElement.load();
+        this.videoElement.play();
+
+        // Download-Button
+        const downloadBtn = document.getElementById('dvp-download');
+        if (allowDownload && downloadBtn) {
+            downloadBtn.style.display = 'inline-block';
+            downloadBtn.href = videoPath;
+            downloadBtn.download = videoPath.split('/').pop();
+        } else if (downloadBtn) {
+            downloadBtn.style.display = 'none';
+        }
+    },
+
+    backToLive: function() {
+        // Video stoppen
+        if (this.videoElement) {
+            this.videoElement.pause();
+            this.videoElement.src = '';
+        }
+
+        // Player verstecken
+        document.getElementById('daily-video-player').style.display = 'none';
+
+        // Live-Stream anzeigen
+        document.getElementById('webcam-player').style.display = 'block';
+    },
+
+    // Wird vom Kalender aufgerufen
+    handleCalendarClick: function(videoPath, playInPlayer, allowDownload) {
+        if (playInPlayer) {
+            this.playVideo(videoPath, allowDownload);
+        } else {
+            // Nur Download
+            window.location.href = videoPath;
+        }
+    }
+};
+
+// Initialisierung
+document.addEventListener('DOMContentLoaded', function() {
+    DailyVideoPlayer.init();
+});

aurora-livecam/js/video-zoom.js

@@ -0,0 +1,215 @@
+/**
+ * Video Zoom & Pan Controller
+ * Zoomt auf Wrapper-Layer statt direkt auf Video-Elemente
+ */
+(() => {
+    const config = window.zoomConfig || {};
+    if (!config.enabled) return;
+
+    let currentZoom = 1;
+    let panX = 0;
+    let panY = 0;
+    let isDragging = false;
+    let lastX = 0;
+    let lastY = 0;
+
+    const minZoom = Number(config.minZoom || 1);
+    const maxZoom = Number(config.maxZoom || 4);
+
+    const slider = document.getElementById('zoom-range');
+    const valueEl = document.getElementById('zoom-value');
+
+    // Wrapper-IDs für jeden Modus
+    const wrapperIds = ['live-video-wrapper', 'timelapse-wrapper', 'daily-video-wrapper'];
+
+    // Finde den aktuell sichtbaren Wrapper
+    function getActiveWrapper() {
+        // Prüfe daily-video-player
+        const dailyPlayer = document.getElementById('daily-video-player');
+        if (dailyPlayer && dailyPlayer.style.display !== 'none') {
+            return document.getElementById('daily-video-wrapper');
+        }
+
+        // Prüfe timelapse-viewer
+        const timelapseViewer = document.getElementById('timelapse-viewer');
+        if (timelapseViewer && timelapseViewer.style.display !== 'none') {
+            return document.getElementById('timelapse-wrapper');
+        }
+
+        // Fallback: Live-Video
+        return document.getElementById('live-video-wrapper');
+    }
+
+    // Wende Transform auf ALLE Wrapper an (damit beim Wechsel der Zoom erhalten bleibt)
+    function applyTransform() {
+        // Bei Zoom 1x: Kein Pan
+        if (currentZoom <= 1) {
+            panX = 0;
+            panY = 0;
+        }
+
+        // Pan begrenzen basierend auf Zoom
+        const maxPan = (currentZoom - 1) * 50;
+        panX = Math.max(-maxPan, Math.min(maxPan, panX));
+        panY = Math.max(-maxPan, Math.min(maxPan, panY));
+
+        // Transform auf alle Wrapper anwenden
+        wrapperIds.forEach(id => {
+            const wrapper = document.getElementById(id);
+            if (wrapper) {
+                wrapper.style.transform = `scale(${currentZoom}) translate(${panX}%, ${panY}%)`;
+                wrapper.style.transition = isDragging ? 'none' : 'transform 0.15s ease-out';
+            }
+        });
+
+        // UI Update
+        if (valueEl) valueEl.textContent = `${currentZoom.toFixed(1)}x`;
+        if (slider) slider.value = currentZoom;
+
+        // Cursor Update
+        updateCursor();
+    }
+
+    function updateCursor() {
+        const container = document.querySelector('.video-container');
+        if (container) {
+            if (currentZoom > 1) {
+                container.classList.add('zoomed');
+            } else {
+                container.classList.remove('zoomed');
+            }
+        }
+    }
+
+    // Zoom setzen
+    function setZoom(value) {
+        currentZoom = Math.max(minZoom, Math.min(maxZoom, value));
+        applyTransform();
+    }
+
+    // Zoom anpassen
+    function adjustZoom(delta) {
+        setZoom(currentZoom + delta);
+    }
+
+    // Zoom zurücksetzen
+    function resetZoom() {
+        currentZoom = 1;
+        panX = 0;
+        panY = 0;
+        applyTransform();
+    }
+
+    // Mouse Events für Pan
+    function setupPanEvents() {
+        const container = document.querySelector('.video-container');
+        if (!container) return;
+
+        // Mousedown - Start dragging
+        container.addEventListener('mousedown', (e) => {
+            if (currentZoom <= 1) return;
+            // Ignoriere Klicks auf Controls
+            if (e.target.closest('.zoom-controls, button, a')) return;
+
+            isDragging = true;
+            lastX = e.clientX;
+            lastY = e.clientY;
+            e.preventDefault();
+        });
+
+        // Mousemove - Dragging
+        document.addEventListener('mousemove', (e) => {
+            if (!isDragging) return;
+
+            const deltaX = e.clientX - lastX;
+            const deltaY = e.clientY - lastY;
+
+            // Sensitivität basierend auf Zoom
+            const sensitivity = 0.15 / currentZoom;
+            panX += deltaX * sensitivity;
+            panY += deltaY * sensitivity;
+
+            lastX = e.clientX;
+            lastY = e.clientY;
+
+            applyTransform();
+        });
+
+        // Mouseup - Stop dragging
+        document.addEventListener('mouseup', () => {
+            isDragging = false;
+        });
+
+        // Mouse leave
+        document.addEventListener('mouseleave', () => {
+            isDragging = false;
+        });
+
+        // Touch Events für Mobile
+        container.addEventListener('touchstart', (e) => {
+            if (currentZoom <= 1 || e.touches.length !== 1) return;
+            if (e.target.closest('.zoom-controls, button, a')) return;
+
+            isDragging = true;
+            lastX = e.touches[0].clientX;
+            lastY = e.touches[0].clientY;
+        }, { passive: true });
+
+        container.addEventListener('touchmove', (e) => {
+            if (!isDragging || e.touches.length !== 1) return;
+
+            const deltaX = e.touches[0].clientX - lastX;
+            const deltaY = e.touches[0].clientY - lastY;
+
+            const sensitivity = 0.15 / currentZoom;
+            panX += deltaX * sensitivity;
+            panY += deltaY * sensitivity;
+
+            lastX = e.touches[0].clientX;
+            lastY = e.touches[0].clientY;
+
+            applyTransform();
+        }, { passive: true });
+
+        container.addEventListener('touchend', () => {
+            isDragging = false;
+        });
+
+        // Doppelklick zum Zurücksetzen
+        container.addEventListener('dblclick', (e) => {
+            if (e.target.closest('.zoom-controls, button, a')) return;
+            resetZoom();
+        });
+    }
+
+    // Slider Setup
+    function setupSlider() {
+        if (!slider) return;
+
+        slider.min = minZoom;
+        slider.max = maxZoom;
+        slider.step = 0.5;
+        slider.value = 1;
+
+        slider.addEventListener('input', (e) => {
+            setZoom(Number(e.target.value));
+        });
+    }
+
+    // Globale Funktionen
+    window.adjustZoom = adjustZoom;
+    window.resetZoom = resetZoom;
+    window.setZoom = setZoom;
+
+    // Initialisierung
+    document.addEventListener('DOMContentLoaded', () => {
+        setupSlider();
+        setupPanEvents();
+
+        // Initial State
+        currentZoom = 1;
+        applyTransform();
+
+        console.log('Video Zoom & Pan initialized');
+    });
+})();

aurora-livecam/landing/index.php

@@ -0,0 +1,422 @@
+<?php
+/**
+ * Landing Page - Marketing Seite
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+$settingsManager = new SettingsManager();
+
+// Prüfe ob Landing Page aktiviert
+if (!$settingsManager->isLandingPageEnabled()) {
+    header('Location: /');
+    exit;
+}
+
+$trialDays = $settingsManager->getTrialDays();
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Aurora Livecam - Ihre Webcam als Service</title>
+    <meta name="description" content="Erstellen Sie Ihre eigene Live-Webcam in wenigen Minuten. Wetter-Widget, Timelapse, Analytics und mehr. Jetzt kostenlos testen!">
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        :root {
+            --gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            line-height: 1.6;
+            color: #1a202c;
+        }
+
+        /* Header */
+        .header {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            background: rgba(255,255,255,0.95);
+            backdrop-filter: blur(10px);
+            z-index: 100;
+            border-bottom: 1px solid #e2e8f0;
+        }
+
+        .header-inner {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 1rem 2rem;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .logo {
+            font-size: 1.5rem;
+            font-weight: 700;
+            background: var(--gradient);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            text-decoration: none;
+        }
+
+        .nav-links {
+            display: flex;
+            gap: 2rem;
+            align-items: center;
+        }
+
+        .nav-links a {
+            color: #4a5568;
+            text-decoration: none;
+            font-weight: 500;
+            transition: color 0.2s;
+        }
+
+        .nav-links a:hover {
+            color: #667eea;
+        }
+
+        /* Hero */
+        .hero {
+            padding: 8rem 2rem 6rem;
+            background: var(--gradient);
+            color: white;
+            text-align: center;
+        }
+
+        .hero h1 {
+            font-size: 3rem;
+            font-weight: 800;
+            margin-bottom: 1.5rem;
+            max-width: 800px;
+            margin-left: auto;
+            margin-right: auto;
+        }
+
+        .hero p {
+            font-size: 1.25rem;
+            opacity: 0.9;
+            max-width: 600px;
+            margin: 0 auto 2rem;
+        }
+
+        .hero-buttons {
+            display: flex;
+            gap: 1rem;
+            justify-content: center;
+            flex-wrap: wrap;
+        }
+
+        .btn-hero {
+            padding: 1rem 2rem;
+            border-radius: 0.5rem;
+            font-size: 1.1rem;
+            font-weight: 600;
+            text-decoration: none;
+            transition: transform 0.2s, box-shadow 0.2s;
+        }
+
+        .btn-hero-primary {
+            background: white;
+            color: #667eea;
+        }
+
+        .btn-hero-secondary {
+            background: rgba(255,255,255,0.2);
+            color: white;
+            border: 2px solid rgba(255,255,255,0.5);
+        }
+
+        .btn-hero:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 20px rgba(0,0,0,0.2);
+        }
+
+        .trial-badge {
+            display: inline-block;
+            background: rgba(255,255,255,0.2);
+            padding: 0.5rem 1rem;
+            border-radius: 2rem;
+            margin-top: 2rem;
+            font-size: 0.9rem;
+        }
+
+        /* Features */
+        .features {
+            padding: 6rem 2rem;
+            background: #f7fafc;
+        }
+
+        .section-title {
+            text-align: center;
+            margin-bottom: 4rem;
+        }
+
+        .section-title h2 {
+            font-size: 2.5rem;
+            margin-bottom: 1rem;
+        }
+
+        .section-title p {
+            color: #718096;
+            font-size: 1.1rem;
+        }
+
+        .features-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 2rem;
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .feature-card {
+            background: white;
+            padding: 2rem;
+            border-radius: 1rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.05);
+            transition: transform 0.2s, box-shadow 0.2s;
+        }
+
+        .feature-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 10px 20px rgba(0,0,0,0.1);
+        }
+
+        .feature-icon {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+        }
+
+        .feature-card h3 {
+            font-size: 1.25rem;
+            margin-bottom: 0.75rem;
+        }
+
+        .feature-card p {
+            color: #718096;
+        }
+
+        /* How it works */
+        .how-it-works {
+            padding: 6rem 2rem;
+            max-width: 1000px;
+            margin: 0 auto;
+        }
+
+        .steps {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 2rem;
+            margin-top: 3rem;
+        }
+
+        .step {
+            text-align: center;
+        }
+
+        .step-number {
+            width: 60px;
+            height: 60px;
+            background: var(--gradient);
+            color: white;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.5rem;
+            font-weight: 700;
+            margin: 0 auto 1rem;
+        }
+
+        .step h4 {
+            margin-bottom: 0.5rem;
+        }
+
+        .step p {
+            color: #718096;
+            font-size: 0.9rem;
+        }
+
+        /* CTA */
+        .cta {
+            padding: 6rem 2rem;
+            background: var(--gradient);
+            color: white;
+            text-align: center;
+        }
+
+        .cta h2 {
+            font-size: 2.5rem;
+            margin-bottom: 1rem;
+        }
+
+        .cta p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+            margin-bottom: 2rem;
+        }
+
+        /* Footer */
+        .footer {
+            background: #1a202c;
+            color: #a0aec0;
+            padding: 3rem 2rem;
+        }
+
+        .footer-inner {
+            max-width: 1200px;
+            margin: 0 auto;
+            display: flex;
+            justify-content: space-between;
+            flex-wrap: wrap;
+            gap: 2rem;
+        }
+
+        .footer-links a {
+            color: #a0aec0;
+            text-decoration: none;
+            margin-right: 1.5rem;
+        }
+
+        .footer-links a:hover {
+            color: white;
+        }
+
+        /* Responsive */
+        @media (max-width: 768px) {
+            .hero h1 { font-size: 2rem; }
+            .nav-links { display: none; }
+            .features-grid { grid-template-columns: 1fr; }
+        }
+    </style>
+</head>
+<body>
+    <!-- Header -->
+    <header class="header">
+        <div class="header-inner">
+            <a href="/" class="logo">Aurora Livecam</a>
+            <nav class="nav-links">
+                <a href="#features">Features</a>
+                <a href="/landing/pricing.php">Preise</a>
+                <a href="/dashboard/login.php">Login</a>
+                <a href="/onboarding/register.php" class="btn btn-primary btn-sm">Kostenlos starten</a>
+            </nav>
+        </div>
+    </header>
+
+    <!-- Hero -->
+    <section class="hero">
+        <h1>Ihre Webcam als Service - in 5 Minuten online</h1>
+        <p>Erstellen Sie Ihre eigene Live-Webcam-Website mit Wetter-Widget, Timelapse, Analytics und mehr. Keine Programmierkenntnisse erforderlich.</p>
+        <div class="hero-buttons">
+            <a href="/onboarding/register.php" class="btn-hero btn-hero-primary">
+                Jetzt starten
+            </a>
+            <a href="#features" class="btn-hero btn-hero-secondary">
+                Features ansehen
+            </a>
+        </div>
+        <div class="trial-badge">
+            <?php echo $trialDays; ?> Tage kostenlos testen - Keine Kreditkarte erforderlich
+        </div>
+    </section>
+
+    <!-- Features -->
+    <section class="features" id="features">
+        <div class="section-title">
+            <h2>Alles was Sie brauchen</h2>
+            <p>Professionelle Features für Ihre Live-Webcam</p>
+        </div>
+        <div class="features-grid">
+            <div class="feature-card">
+                <div class="feature-icon">📹</div>
+                <h3>Live-Streaming</h3>
+                <p>HLS, RTMP oder WebRTC - verbinden Sie jeden Stream in Sekunden. Automatische Qualitätsanpassung inklusive.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">🌤️</div>
+                <h3>Wetter-Widget</h3>
+                <p>Zeigen Sie Temperatur, Wind, Luftdruck und mehr an. Kostenlose Open-Meteo Integration ohne API-Key.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">⏱️</div>
+                <h3>Timelapse</h3>
+                <p>Automatische Zeitraffer-Erstellung. Scrubben Sie durch den ganzen Tag mit variabler Geschwindigkeit.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">🔍</div>
+                <h3>Zoom & Pan</h3>
+                <p>Lassen Sie Besucher in Ihren Stream hineinzoomen. Unterstützt Touch-Gesten und Maus-Steuerung.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">📊</div>
+                <h3>Analytics</h3>
+                <p>Sehen Sie wer Ihre Webcam besucht. Echtzeit-Zuschauerzähler und detaillierte Statistiken.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">🎨</div>
+                <h3>Custom Branding</h3>
+                <p>Ihr Logo, Ihre Farben, Ihre Domain. Machen Sie die Webcam zu Ihrer eigenen.</p>
+            </div>
+        </div>
+    </section>
+
+    <!-- How it works -->
+    <section class="how-it-works">
+        <div class="section-title">
+            <h2>So einfach geht's</h2>
+            <p>In 3 Schritten zur eigenen Livecam</p>
+        </div>
+        <div class="steps">
+            <div class="step">
+                <div class="step-number">1</div>
+                <h4>Registrieren</h4>
+                <p>Erstellen Sie in 30 Sekunden Ihr kostenloses Konto.</p>
+            </div>
+            <div class="step">
+                <div class="step-number">2</div>
+                <h4>Stream verbinden</h4>
+                <p>Fügen Sie Ihre Stream-URL ein. Wir unterstützen alle gängigen Formate.</p>
+            </div>
+            <div class="step">
+                <div class="step-number">3</div>
+                <h4>Anpassen & Teilen</h4>
+                <p>Personalisieren Sie Ihre Seite und teilen Sie den Link.</p>
+            </div>
+        </div>
+    </section>
+
+    <!-- CTA -->
+    <section class="cta">
+        <h2>Bereit loszulegen?</h2>
+        <p><?php echo $trialDays; ?> Tage kostenlos testen - keine Kreditkarte erforderlich</p>
+        <a href="/onboarding/register.php" class="btn-hero btn-hero-primary">
+            Jetzt kostenlos starten
+        </a>
+    </section>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-inner">
+            <div>
+                © <?php echo date('Y'); ?> Aurora Livecam. Alle Rechte vorbehalten.
+            </div>
+            <div class="footer-links">
+                <a href="/terms">AGB</a>
+                <a href="/privacy">Datenschutz</a>
+                <a href="/imprint">Impressum</a>
+                <a href="mailto:support@aurora-livecam.com">Kontakt</a>
+            </div>
+        </div>
+    </footer>
+</body>
+</html>

aurora-livecam/landing/pricing.php

@@ -0,0 +1,497 @@
+<?php
+/**
+ * Landing Page - Preise
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Billing\SubscriptionManager;
+
+$settingsManager = new SettingsManager();
+
+// Pläne laden
+$plans = [];
+try {
+    $subscriptions = new SubscriptionManager();
+    $plans = $subscriptions->getPlans();
+} catch (\Exception $e) {
+    // Fallback-Pläne
+    $plans = [
+        ['name' => 'Free', 'slug' => 'free', 'price_monthly' => 0, 'features' => ['max_viewers' => 10, 'weather_widget' => true]],
+        ['name' => 'Basic', 'slug' => 'basic', 'price_monthly' => 19, 'features' => ['max_viewers' => 50, 'weather_widget' => true, 'timelapse' => true, 'analytics' => true]],
+        ['name' => 'Professional', 'slug' => 'professional', 'price_monthly' => 49, 'features' => ['max_viewers' => 200, 'custom_domain' => true, 'weather_widget' => true, 'timelapse' => true, 'analytics' => true, 'branding' => true]],
+        ['name' => 'Enterprise', 'slug' => 'enterprise', 'price_monthly' => 149, 'features' => ['max_viewers' => -1, 'custom_domain' => true, 'weather_widget' => true, 'timelapse' => true, 'analytics' => true, 'branding' => true, 'priority_support' => true]],
+    ];
+}
+
+$trialDays = $settingsManager->getTrialDays();
+
+// Feature-Labels
+$featureLabels = [
+    'max_viewers' => 'Gleichzeitige Zuschauer',
+    'storage_gb' => 'Speicherplatz',
+    'custom_domain' => 'Eigene Domain',
+    'weather_widget' => 'Wetter-Widget',
+    'timelapse' => 'Timelapse',
+    'analytics' => 'Analytics & Statistiken',
+    'branding' => 'Custom Branding',
+    'priority_support' => 'Priority Support',
+];
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Preise - Aurora Livecam</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        :root {
+            --gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            line-height: 1.6;
+            color: #1a202c;
+            background: #f7fafc;
+        }
+
+        .header {
+            background: white;
+            border-bottom: 1px solid #e2e8f0;
+            padding: 1rem 2rem;
+        }
+
+        .header-inner {
+            max-width: 1200px;
+            margin: 0 auto;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .logo {
+            font-size: 1.5rem;
+            font-weight: 700;
+            background: var(--gradient);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            text-decoration: none;
+        }
+
+        .nav-links a {
+            color: #4a5568;
+            text-decoration: none;
+            margin-left: 1.5rem;
+        }
+
+        .page-header {
+            text-align: center;
+            padding: 4rem 2rem;
+            background: var(--gradient);
+            color: white;
+        }
+
+        .page-header h1 {
+            font-size: 2.5rem;
+            margin-bottom: 1rem;
+        }
+
+        .page-header p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+
+        .pricing-toggle {
+            display: flex;
+            justify-content: center;
+            gap: 1rem;
+            margin-top: 2rem;
+            align-items: center;
+        }
+
+        .pricing-toggle span {
+            font-size: 0.9rem;
+        }
+
+        .pricing-toggle .active {
+            font-weight: 600;
+        }
+
+        .toggle-switch {
+            width: 60px;
+            height: 30px;
+            background: rgba(255,255,255,0.3);
+            border-radius: 15px;
+            position: relative;
+            cursor: pointer;
+        }
+
+        .toggle-switch::after {
+            content: '';
+            position: absolute;
+            width: 26px;
+            height: 26px;
+            background: white;
+            border-radius: 50%;
+            top: 2px;
+            left: 2px;
+            transition: 0.3s;
+        }
+
+        .toggle-switch.yearly::after {
+            left: 32px;
+        }
+
+        .save-badge {
+            background: #48bb78;
+            padding: 0.25rem 0.5rem;
+            border-radius: 0.25rem;
+            font-size: 0.75rem;
+            font-weight: 600;
+        }
+
+        .pricing-container {
+            max-width: 1200px;
+            margin: -3rem auto 4rem;
+            padding: 0 2rem;
+        }
+
+        .pricing-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+            gap: 1.5rem;
+        }
+
+        .pricing-card {
+            background: white;
+            border-radius: 1rem;
+            padding: 2rem;
+            box-shadow: 0 10px 40px rgba(0,0,0,0.1);
+            position: relative;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .pricing-card.featured {
+            border: 2px solid #667eea;
+            transform: scale(1.05);
+        }
+
+        .pricing-card.featured::before {
+            content: 'Beliebt';
+            position: absolute;
+            top: -12px;
+            left: 50%;
+            transform: translateX(-50%);
+            background: var(--gradient);
+            color: white;
+            padding: 0.25rem 1rem;
+            border-radius: 1rem;
+            font-size: 0.75rem;
+            font-weight: 600;
+        }
+
+        .pricing-card h3 {
+            font-size: 1.25rem;
+            margin-bottom: 0.5rem;
+        }
+
+        .pricing-card .price {
+            font-size: 3rem;
+            font-weight: 800;
+            margin: 1rem 0;
+        }
+
+        .pricing-card .price span {
+            font-size: 1rem;
+            font-weight: 400;
+            color: #718096;
+        }
+
+        .pricing-card .price-yearly {
+            display: none;
+        }
+
+        .yearly-mode .price-monthly { display: none; }
+        .yearly-mode .price-yearly { display: block; }
+
+        .pricing-card ul {
+            list-style: none;
+            flex: 1;
+            margin: 1.5rem 0;
+        }
+
+        .pricing-card li {
+            padding: 0.5rem 0;
+            color: #4a5568;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .pricing-card li.included::before {
+            content: '✓';
+            color: #48bb78;
+            font-weight: bold;
+        }
+
+        .pricing-card li.not-included {
+            color: #a0aec0;
+            text-decoration: line-through;
+        }
+
+        .pricing-card li.not-included::before {
+            content: '✗';
+            color: #e53e3e;
+        }
+
+        .pricing-card .btn {
+            width: 100%;
+            padding: 1rem;
+            border: none;
+            border-radius: 0.5rem;
+            font-size: 1rem;
+            font-weight: 600;
+            cursor: pointer;
+            text-decoration: none;
+            text-align: center;
+            transition: all 0.2s;
+        }
+
+        .pricing-card .btn-primary {
+            background: var(--gradient);
+            color: white;
+        }
+
+        .pricing-card .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+        }
+
+        .pricing-card .btn-secondary {
+            background: #e2e8f0;
+            color: #4a5568;
+        }
+
+        .faq {
+            max-width: 800px;
+            margin: 0 auto 4rem;
+            padding: 0 2rem;
+        }
+
+        .faq h2 {
+            text-align: center;
+            margin-bottom: 2rem;
+        }
+
+        .faq-item {
+            background: white;
+            border-radius: 0.5rem;
+            margin-bottom: 1rem;
+            overflow: hidden;
+        }
+
+        .faq-question {
+            padding: 1.25rem;
+            font-weight: 600;
+            cursor: pointer;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .faq-answer {
+            padding: 0 1.25rem 1.25rem;
+            color: #718096;
+            display: none;
+        }
+
+        .faq-item.open .faq-answer {
+            display: block;
+        }
+
+        .footer {
+            background: #1a202c;
+            color: #a0aec0;
+            padding: 2rem;
+            text-align: center;
+        }
+
+        @media (max-width: 768px) {
+            .pricing-card.featured {
+                transform: none;
+            }
+            .pricing-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <header class="header">
+        <div class="header-inner">
+            <a href="/landing/" class="logo">Aurora Livecam</a>
+            <nav class="nav-links">
+                <a href="/landing/">Home</a>
+                <a href="/dashboard/login.php">Login</a>
+                <a href="/onboarding/register.php" class="btn btn-primary btn-sm">Kostenlos starten</a>
+            </nav>
+        </div>
+    </header>
+
+    <section class="page-header">
+        <h1>Einfache, transparente Preise</h1>
+        <p><?php echo $trialDays; ?> Tage kostenlos testen - jederzeit kündbar</p>
+
+        <div class="pricing-toggle">
+            <span class="monthly-label active">Monatlich</span>
+            <div class="toggle-switch" id="billing-toggle"></div>
+            <span class="yearly-label">Jährlich</span>
+            <span class="save-badge">2 Monate gratis</span>
+        </div>
+    </section>
+
+    <div class="pricing-container" id="pricing-container">
+        <div class="pricing-grid">
+            <?php foreach ($plans as $index => $plan): ?>
+            <?php $isFeatured = $plan['slug'] === 'professional'; ?>
+            <div class="pricing-card <?php echo $isFeatured ? 'featured' : ''; ?>">
+                <h3><?php echo htmlspecialchars($plan['name']); ?></h3>
+
+                <div class="price price-monthly">
+                    <?php if ($plan['price_monthly'] > 0): ?>
+                    CHF <?php echo number_format($plan['price_monthly'], 0); ?><span>/Monat</span>
+                    <?php else: ?>
+                    Kostenlos
+                    <?php endif; ?>
+                </div>
+
+                <div class="price price-yearly">
+                    <?php if (isset($plan['price_yearly']) && $plan['price_yearly'] > 0): ?>
+                    CHF <?php echo number_format($plan['price_yearly'] / 12, 0); ?><span>/Monat</span>
+                    <div style="font-size: 0.875rem; color: #718096;">
+                        CHF <?php echo number_format($plan['price_yearly'], 0); ?> jährlich
+                    </div>
+                    <?php elseif ($plan['price_monthly'] > 0): ?>
+                    CHF <?php echo number_format($plan['price_monthly'] * 10 / 12, 0); ?><span>/Monat</span>
+                    <div style="font-size: 0.875rem; color: #718096;">
+                        CHF <?php echo number_format($plan['price_monthly'] * 10, 0); ?> jährlich
+                    </div>
+                    <?php else: ?>
+                    Kostenlos
+                    <?php endif; ?>
+                </div>
+
+                <ul>
+                    <?php
+                    $features = is_array($plan['features']) ? $plan['features'] : json_decode($plan['features'], true) ?? [];
+                    $allFeatures = ['max_viewers', 'weather_widget', 'timelapse', 'analytics', 'custom_domain', 'branding', 'priority_support'];
+
+                    foreach ($allFeatures as $feature):
+                        $hasFeature = !empty($features[$feature]);
+                        $value = $features[$feature] ?? null;
+                    ?>
+                    <li class="<?php echo $hasFeature ? 'included' : 'not-included'; ?>">
+                        <?php
+                        if ($feature === 'max_viewers' && $value) {
+                            echo $value === -1 ? 'Unbegrenzte Zuschauer' : "Bis $value Zuschauer";
+                        } elseif ($feature === 'storage_gb' && $value) {
+                            echo "$value GB Speicher";
+                        } else {
+                            echo $featureLabels[$feature] ?? ucfirst(str_replace('_', ' ', $feature));
+                        }
+                        ?>
+                    </li>
+                    <?php endforeach; ?>
+                </ul>
+
+                <a href="/onboarding/register.php?plan=<?php echo $plan['slug']; ?>"
+                   class="btn <?php echo $isFeatured || $plan['price_monthly'] > 0 ? 'btn-primary' : 'btn-secondary'; ?>">
+                    <?php echo $plan['price_monthly'] > 0 ? 'Jetzt starten' : 'Kostenlos starten'; ?>
+                </a>
+            </div>
+            <?php endforeach; ?>
+        </div>
+    </div>
+
+    <!-- FAQ -->
+    <section class="faq">
+        <h2>Häufige Fragen</h2>
+
+        <div class="faq-item">
+            <div class="faq-question">
+                Kann ich jederzeit wechseln oder kündigen?
+                <span>+</span>
+            </div>
+            <div class="faq-answer">
+                Ja! Sie können Ihren Plan jederzeit upgraden oder downgraden. Bei einer Kündigung bleibt Ihr Zugang bis zum Ende der Abrechnungsperiode aktiv.
+            </div>
+        </div>
+
+        <div class="faq-item">
+            <div class="faq-question">
+                Was passiert nach dem Trial?
+                <span>+</span>
+            </div>
+            <div class="faq-answer">
+                Nach Ablauf der <?php echo $trialDays; ?> Tage werden Sie automatisch auf den kostenlosen Plan umgestellt, sofern Sie kein Abo abschliessen. Keine Sorge, Ihre Daten bleiben erhalten.
+            </div>
+        </div>
+
+        <div class="faq-item">
+            <div class="faq-question">
+                Welche Zahlungsmethoden werden akzeptiert?
+                <span>+</span>
+            </div>
+            <div class="faq-answer">
+                Wir akzeptieren alle gängigen Kreditkarten (Visa, Mastercard, American Express) sowie TWINT und Banküberweisung bei Jahresabos.
+            </div>
+        </div>
+
+        <div class="faq-item">
+            <div class="faq-question">
+                Brauche ich technisches Wissen?
+                <span>+</span>
+            </div>
+            <div class="faq-answer">
+                Nein! Unser Onboarding-Wizard führt Sie Schritt für Schritt durch die Einrichtung. Sie benötigen lediglich eine Stream-URL (HLS/m3u8) von Ihrem Kamera-Anbieter.
+            </div>
+        </div>
+    </section>
+
+    <footer class="footer">
+        © <?php echo date('Y'); ?> Aurora Livecam. Alle Rechte vorbehalten.
+    </footer>
+
+    <script>
+    // Billing toggle
+    const toggle = document.getElementById('billing-toggle');
+    const container = document.getElementById('pricing-container');
+
+    toggle.addEventListener('click', () => {
+        toggle.classList.toggle('yearly');
+        container.classList.toggle('yearly-mode');
+
+        document.querySelector('.monthly-label').classList.toggle('active');
+        document.querySelector('.yearly-label').classList.toggle('active');
+    });
+
+    // FAQ accordion
+    document.querySelectorAll('.faq-question').forEach(q => {
+        q.addEventListener('click', () => {
+            q.parentElement.classList.toggle('open');
+            q.querySelector('span').textContent = q.parentElement.classList.contains('open') ? '−' : '+';
+        });
+    });
+    </script>
+</body>
+</html>

aurora-livecam/onboarding/branding.php

@@ -0,0 +1,253 @@
+<?php
+/**
+ * Onboarding - Branding (Schritt 4)
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Onboarding\OnboardingManager;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+
+if (!$auth->isLoggedIn()) {
+    header('Location: /onboarding/register.php');
+    exit;
+}
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$error = '';
+$branding = [
+    'site_name' => $user['tenant_name'] ?? '',
+    'tagline' => '',
+    'primary_color' => '#667eea',
+    'secondary_color' => '#764ba2',
+];
+
+// Formular verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $branding = [
+        'site_name' => trim($_POST['site_name'] ?? ''),
+        'site_name_full' => trim($_POST['site_name'] ?? ''),
+        'tagline' => trim($_POST['tagline'] ?? ''),
+        'primary_color' => $_POST['primary_color'] ?? '#667eea',
+        'secondary_color' => $_POST['secondary_color'] ?? '#764ba2',
+    ];
+
+    try {
+        $onboarding = new OnboardingManager();
+        $result = $onboarding->saveBranding($tenantId, $branding);
+
+        if ($result['success']) {
+            header('Location: /onboarding/complete.php');
+            exit;
+        } else {
+            $error = $result['error'] ?? 'Fehler beim Speichern';
+        }
+    } catch (\Exception $e) {
+        $error = 'Fehler: ' . $e->getMessage();
+    }
+}
+
+// Skip
+if (isset($_GET['skip'])) {
+    header('Location: /onboarding/complete.php');
+    exit;
+}
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Branding - Aurora Livecam</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        .onboarding-container {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+            padding: 2rem;
+        }
+        .onboarding-box {
+            background: var(--white);
+            padding: 2.5rem;
+            border-radius: 1rem;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+            width: 100%;
+            max-width: 600px;
+        }
+        .progress-steps {
+            display: flex;
+            justify-content: center;
+            gap: 0.5rem;
+            margin-bottom: 1.5rem;
+        }
+        .step {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: var(--gray-300);
+        }
+        .step.active { background: var(--primary); }
+        .step.completed { background: var(--success); }
+        .onboarding-header {
+            text-align: center;
+            margin-bottom: 2rem;
+        }
+        .onboarding-header h1 {
+            font-size: 1.5rem;
+            margin-bottom: 0.5rem;
+        }
+        .color-row {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 1rem;
+        }
+        .preview-card {
+            margin-top: 1.5rem;
+            border-radius: 0.75rem;
+            overflow: hidden;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        }
+        .preview-header {
+            padding: 1.5rem;
+            color: white;
+            text-align: center;
+        }
+        .preview-header h3 {
+            margin: 0;
+            font-size: 1.25rem;
+        }
+        .preview-header p {
+            margin: 0.5rem 0 0 0;
+            opacity: 0.9;
+            font-size: 0.875rem;
+        }
+        .preview-body {
+            padding: 1rem;
+            background: var(--gray-100);
+            text-align: center;
+            font-size: 0.875rem;
+            color: var(--gray-500);
+        }
+        .skip-link {
+            display: block;
+            text-align: center;
+            margin-top: 1.5rem;
+            color: var(--gray-500);
+            font-size: 0.875rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="onboarding-container">
+        <div class="onboarding-box">
+            <div class="progress-steps">
+                <div class="step completed"></div>
+                <div class="step completed"></div>
+                <div class="step completed"></div>
+                <div class="step active"></div>
+            </div>
+
+            <div class="onboarding-header">
+                <h1>🎨 Branding</h1>
+                <p style="color: var(--gray-500);">Personalisieren Sie Ihre Livecam</p>
+            </div>
+
+            <?php if ($error): ?>
+            <div class="alert alert-error"><?php echo htmlspecialchars($error); ?></div>
+            <?php endif; ?>
+
+            <form method="POST" action="">
+                <div class="form-group">
+                    <label class="form-label" for="site_name">Name Ihrer Livecam</label>
+                    <input type="text" id="site_name" name="site_name" class="form-input"
+                           value="<?php echo htmlspecialchars($branding['site_name']); ?>"
+                           placeholder="z.B. Berghütte Webcam">
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="tagline">Slogan / Beschreibung</label>
+                    <input type="text" id="tagline" name="tagline" class="form-input"
+                           value="<?php echo htmlspecialchars($branding['tagline']); ?>"
+                           placeholder="z.B. Live aus den Schweizer Alpen">
+                </div>
+
+                <div class="color-row">
+                    <div class="form-group">
+                        <label class="form-label">Primärfarbe</label>
+                        <div class="color-picker-wrapper">
+                            <input type="color" name="primary_color" id="primary_color" class="color-picker"
+                                   value="<?php echo htmlspecialchars($branding['primary_color']); ?>">
+                            <span class="color-value"><?php echo htmlspecialchars($branding['primary_color']); ?></span>
+                        </div>
+                    </div>
+
+                    <div class="form-group">
+                        <label class="form-label">Sekundärfarbe</label>
+                        <div class="color-picker-wrapper">
+                            <input type="color" name="secondary_color" id="secondary_color" class="color-picker"
+                                   value="<?php echo htmlspecialchars($branding['secondary_color']); ?>">
+                            <span class="color-value"><?php echo htmlspecialchars($branding['secondary_color']); ?></span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Live Preview -->
+                <div class="preview-card">
+                    <div class="preview-header" id="preview-header" style="background: linear-gradient(135deg, <?php echo htmlspecialchars($branding['primary_color']); ?> 0%, <?php echo htmlspecialchars($branding['secondary_color']); ?> 100%);">
+                        <h3 id="preview-name"><?php echo htmlspecialchars($branding['site_name'] ?: 'Ihre Livecam'); ?></h3>
+                        <p id="preview-tagline"><?php echo htmlspecialchars($branding['tagline'] ?: 'Ihr Slogan hier'); ?></p>
+                    </div>
+                    <div class="preview-body">
+                        Live-Vorschau
+                    </div>
+                </div>
+
+                <button type="submit" class="btn btn-primary" style="width: 100%; margin-top: 1.5rem;">
+                    Speichern & abschliessen
+                </button>
+            </form>
+
+            <a href="?skip=1" class="skip-link">
+                Später anpassen →
+            </a>
+        </div>
+    </div>
+
+    <script>
+    // Live preview updates
+    document.getElementById('site_name').addEventListener('input', (e) => {
+        document.getElementById('preview-name').textContent = e.target.value || 'Ihre Livecam';
+    });
+
+    document.getElementById('tagline').addEventListener('input', (e) => {
+        document.getElementById('preview-tagline').textContent = e.target.value || 'Ihr Slogan hier';
+    });
+
+    document.getElementById('primary_color').addEventListener('input', updateColors);
+    document.getElementById('secondary_color').addEventListener('input', updateColors);
+
+    function updateColors() {
+        const primary = document.getElementById('primary_color').value;
+        const secondary = document.getElementById('secondary_color').value;
+        document.getElementById('preview-header').style.background =
+            `linear-gradient(135deg, ${primary} 0%, ${secondary} 100%)`;
+
+        document.querySelectorAll('.color-value')[0].textContent = primary;
+        document.querySelectorAll('.color-value')[1].textContent = secondary;
+    }
+    </script>
+</body>
+</html>

aurora-livecam/onboarding/complete.php

@@ -0,0 +1,237 @@
+<?php
+/**
+ * Onboarding - Abgeschlossen
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Onboarding\OnboardingManager;
+use AuroraLivecam\Core\Database;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+
+if (!$auth->isLoggedIn()) {
+    header('Location: /onboarding/register.php');
+    exit;
+}
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+// Onboarding abschliessen
+try {
+    $onboarding = new OnboardingManager();
+    $onboarding->complete($tenantId);
+} catch (\Exception $e) {
+    // Ignorieren wenn DB nicht verfügbar
+}
+
+// Tenant-Info laden
+$tenantSlug = 'demo';
+$subdomain = '';
+
+try {
+    $db = Database::getInstance();
+    $tenant = $db->fetchOne("SELECT slug FROM tenants WHERE id = ?", [$tenantId]);
+    if ($tenant) {
+        $tenantSlug = $tenant['slug'];
+        $subdomain = $tenantSlug . '.aurora-livecam.com';
+    }
+} catch (\Exception $e) {
+    // Fallback
+}
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Fertig! - Aurora Livecam</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        .complete-container {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+            padding: 2rem;
+        }
+        .complete-box {
+            background: var(--white);
+            padding: 3rem;
+            border-radius: 1rem;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+            width: 100%;
+            max-width: 600px;
+            text-align: center;
+        }
+        .complete-icon {
+            font-size: 5rem;
+            margin-bottom: 1.5rem;
+            animation: bounce 0.5s ease;
+        }
+        @keyframes bounce {
+            0%, 100% { transform: translateY(0); }
+            50% { transform: translateY(-10px); }
+        }
+        .complete-box h1 {
+            font-size: 2rem;
+            margin-bottom: 1rem;
+            color: var(--success);
+        }
+        .complete-box p {
+            color: var(--gray-600);
+            margin-bottom: 2rem;
+            font-size: 1.1rem;
+        }
+        .url-box {
+            background: var(--gray-100);
+            border-radius: 0.5rem;
+            padding: 1rem;
+            margin-bottom: 2rem;
+        }
+        .url-box label {
+            display: block;
+            font-size: 0.875rem;
+            color: var(--gray-500);
+            margin-bottom: 0.5rem;
+        }
+        .url-box .url {
+            font-family: monospace;
+            font-size: 1rem;
+            color: var(--primary);
+            word-break: break-all;
+        }
+        .action-buttons {
+            display: flex;
+            gap: 1rem;
+            justify-content: center;
+            flex-wrap: wrap;
+        }
+        .next-steps {
+            margin-top: 2.5rem;
+            text-align: left;
+            background: var(--gray-50);
+            border-radius: 0.5rem;
+            padding: 1.5rem;
+        }
+        .next-steps h3 {
+            font-size: 1rem;
+            margin-bottom: 1rem;
+            color: var(--gray-700);
+        }
+        .next-steps ul {
+            list-style: none;
+            padding: 0;
+            margin: 0;
+        }
+        .next-steps li {
+            padding: 0.5rem 0;
+            padding-left: 1.5rem;
+            position: relative;
+            color: var(--gray-600);
+        }
+        .next-steps li::before {
+            content: '→';
+            position: absolute;
+            left: 0;
+            color: var(--primary);
+        }
+        .confetti {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            overflow: hidden;
+            z-index: 1000;
+        }
+        .confetti-piece {
+            position: absolute;
+            width: 10px;
+            height: 10px;
+            background: var(--primary);
+            animation: confetti-fall 3s ease-out forwards;
+        }
+        @keyframes confetti-fall {
+            0% { transform: translateY(-100px) rotate(0deg); opacity: 1; }
+            100% { transform: translateY(100vh) rotate(720deg); opacity: 0; }
+        }
+    </style>
+</head>
+<body>
+    <div class="confetti" id="confetti"></div>
+
+    <div class="complete-container">
+        <div class="complete-box">
+            <div class="complete-icon">🎉</div>
+            <h1>Herzlichen Glückwunsch!</h1>
+            <p>Ihre Livecam ist jetzt eingerichtet und bereit.</p>
+
+            <?php if ($subdomain): ?>
+            <div class="url-box">
+                <label>Ihre Livecam-Adresse:</label>
+                <div class="url">https://<?php echo htmlspecialchars($subdomain); ?></div>
+            </div>
+            <?php endif; ?>
+
+            <div class="action-buttons">
+                <a href="/dashboard/" class="btn btn-primary">
+                    Zum Dashboard
+                </a>
+                <a href="/" class="btn btn-secondary" target="_blank">
+                    Livecam ansehen
+                </a>
+            </div>
+
+            <div class="next-steps">
+                <h3>Nächste Schritte</h3>
+                <ul>
+                    <li>Stream-URL im Dashboard anpassen (falls noch nicht geschehen)</li>
+                    <li>Logo und Farben im Branding-Bereich hochladen</li>
+                    <li>Wetter-Widget konfigurieren</li>
+                    <li>Eigene Domain verbinden (optional)</li>
+                    <?php if ($settingsManager->isBillingEnabled()): ?>
+                    <li>Abo auswählen für mehr Funktionen</li>
+                    <?php endif; ?>
+                </ul>
+            </div>
+        </div>
+    </div>
+
+    <script>
+    // Confetti Animation
+    function createConfetti() {
+        const container = document.getElementById('confetti');
+        const colors = ['#667eea', '#764ba2', '#f093fb', '#48bb78', '#ed8936'];
+
+        for (let i = 0; i < 50; i++) {
+            const piece = document.createElement('div');
+            piece.className = 'confetti-piece';
+            piece.style.left = Math.random() * 100 + '%';
+            piece.style.background = colors[Math.floor(Math.random() * colors.length)];
+            piece.style.animationDelay = Math.random() * 2 + 's';
+            piece.style.width = (Math.random() * 10 + 5) + 'px';
+            piece.style.height = piece.style.width;
+            container.appendChild(piece);
+        }
+
+        // Cleanup after animation
+        setTimeout(() => {
+            container.innerHTML = '';
+        }, 5000);
+    }
+
+    createConfetti();
+    </script>
+</body>
+</html>

aurora-livecam/onboarding/register.php

@@ -0,0 +1,265 @@
+<?php
+/**
+ * Onboarding - Registrierung
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Onboarding\OnboardingManager;
+use AuroraLivecam\Auth\AuthManager;
+
+$settingsManager = new SettingsManager();
+
+// Prüfe ob Self-Registration aktiviert ist
+if (!$settingsManager->isSelfRegistrationEnabled()) {
+    header('Location: /');
+    exit;
+}
+
+$auth = new AuthManager();
+
+// Bereits eingeloggt?
+if ($auth->isLoggedIn()) {
+    header('Location: /dashboard/');
+    exit;
+}
+
+$errors = [];
+$formData = [];
+$success = false;
+
+// Formular verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $formData = [
+        'name' => trim($_POST['name'] ?? ''),
+        'company_name' => trim($_POST['company_name'] ?? ''),
+        'email' => trim($_POST['email'] ?? ''),
+        'password' => $_POST['password'] ?? '',
+        'password_confirm' => $_POST['password_confirm'] ?? '',
+        'stream_url' => trim($_POST['stream_url'] ?? ''),
+        'accept_terms' => isset($_POST['accept_terms']),
+    ];
+
+    try {
+        $onboarding = new OnboardingManager();
+        $result = $onboarding->register($formData);
+
+        if ($result['success']) {
+            // Session starten und User einloggen
+            $auth->login($formData['email'], $formData['password']);
+
+            // Zur nächsten Seite weiterleiten
+            if ($onboarding->requiresEmailVerification()) {
+                // Token für Demo-Zwecke in Session speichern
+                $_SESSION['verification_token'] = $result['verification_token'];
+                header('Location: /onboarding/verify.php');
+            } else {
+                header('Location: /onboarding/stream.php');
+            }
+            exit;
+        } else {
+            $errors = $result['errors'];
+        }
+    } catch (\Exception $e) {
+        $errors['general'] = 'Registrierung fehlgeschlagen: ' . $e->getMessage();
+    }
+}
+
+$trialDays = $settingsManager->getTrialDays();
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Registrierung - Aurora Livecam</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        .register-container {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+            padding: 2rem;
+        }
+        .register-box {
+            background: var(--white);
+            padding: 2.5rem;
+            border-radius: 1rem;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+            width: 100%;
+            max-width: 500px;
+        }
+        .register-header {
+            text-align: center;
+            margin-bottom: 2rem;
+        }
+        .register-header h1 {
+            font-size: 1.75rem;
+            margin-bottom: 0.5rem;
+        }
+        .register-header p {
+            color: var(--gray-500);
+        }
+        .trial-badge {
+            display: inline-block;
+            background: linear-gradient(135deg, var(--success) 0%, #38a169 100%);
+            color: white;
+            padding: 0.25rem 0.75rem;
+            border-radius: 9999px;
+            font-size: 0.875rem;
+            margin-top: 0.5rem;
+        }
+        .form-row {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 1rem;
+        }
+        .error-text {
+            color: var(--danger);
+            font-size: 0.875rem;
+            margin-top: 0.25rem;
+        }
+        .input-error {
+            border-color: var(--danger) !important;
+        }
+        .terms-text {
+            font-size: 0.875rem;
+            color: var(--gray-600);
+        }
+        .terms-text a {
+            color: var(--primary);
+        }
+        .divider {
+            display: flex;
+            align-items: center;
+            margin: 1.5rem 0;
+            color: var(--gray-400);
+        }
+        .divider::before,
+        .divider::after {
+            content: '';
+            flex: 1;
+            height: 1px;
+            background: var(--gray-300);
+        }
+        .divider span {
+            padding: 0 1rem;
+            font-size: 0.875rem;
+        }
+        @media (max-width: 500px) {
+            .form-row {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="register-container">
+        <div class="register-box">
+            <div class="register-header">
+                <h1>Jetzt starten</h1>
+                <p>Erstellen Sie Ihre eigene Live-Webcam</p>
+                <span class="trial-badge"><?php echo $trialDays; ?> Tage kostenlos testen</span>
+            </div>
+
+            <?php if (!empty($errors['general'])): ?>
+            <div class="alert alert-error"><?php echo htmlspecialchars($errors['general']); ?></div>
+            <?php endif; ?>
+
+            <form method="POST" action="" novalidate>
+                <div class="form-row">
+                    <div class="form-group">
+                        <label class="form-label" for="name">Ihr Name *</label>
+                        <input type="text" id="name" name="name" class="form-input <?php echo isset($errors['name']) ? 'input-error' : ''; ?>"
+                               value="<?php echo htmlspecialchars($formData['name'] ?? ''); ?>" required>
+                        <?php if (isset($errors['name'])): ?>
+                        <p class="error-text"><?php echo htmlspecialchars($errors['name']); ?></p>
+                        <?php endif; ?>
+                    </div>
+
+                    <div class="form-group">
+                        <label class="form-label" for="company_name">Webcam / Firma *</label>
+                        <input type="text" id="company_name" name="company_name" class="form-input <?php echo isset($errors['company_name']) ? 'input-error' : ''; ?>"
+                               value="<?php echo htmlspecialchars($formData['company_name'] ?? ''); ?>"
+                               placeholder="z.B. Berghütte Webcam" required>
+                        <?php if (isset($errors['company_name'])): ?>
+                        <p class="error-text"><?php echo htmlspecialchars($errors['company_name']); ?></p>
+                        <?php endif; ?>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="email">E-Mail-Adresse *</label>
+                    <input type="email" id="email" name="email" class="form-input <?php echo isset($errors['email']) ? 'input-error' : ''; ?>"
+                           value="<?php echo htmlspecialchars($formData['email'] ?? ''); ?>" required>
+                    <?php if (isset($errors['email'])): ?>
+                    <p class="error-text"><?php echo htmlspecialchars($errors['email']); ?></p>
+                    <?php endif; ?>
+                </div>
+
+                <div class="form-row">
+                    <div class="form-group">
+                        <label class="form-label" for="password">Passwort *</label>
+                        <input type="password" id="password" name="password" class="form-input <?php echo isset($errors['password']) ? 'input-error' : ''; ?>"
+                               minlength="8" required>
+                        <?php if (isset($errors['password'])): ?>
+                        <p class="error-text"><?php echo htmlspecialchars($errors['password']); ?></p>
+                        <?php endif; ?>
+                    </div>
+
+                    <div class="form-group">
+                        <label class="form-label" for="password_confirm">Passwort bestätigen *</label>
+                        <input type="password" id="password_confirm" name="password_confirm" class="form-input <?php echo isset($errors['password_confirm']) ? 'input-error' : ''; ?>"
+                               required>
+                        <?php if (isset($errors['password_confirm'])): ?>
+                        <p class="error-text"><?php echo htmlspecialchars($errors['password_confirm']); ?></p>
+                        <?php endif; ?>
+                    </div>
+                </div>
+
+                <div class="divider"><span>Optional</span></div>
+
+                <div class="form-group">
+                    <label class="form-label" for="stream_url">Stream-URL</label>
+                    <input type="url" id="stream_url" name="stream_url" class="form-input <?php echo isset($errors['stream_url']) ? 'input-error' : ''; ?>"
+                           value="<?php echo htmlspecialchars($formData['stream_url'] ?? ''); ?>"
+                           placeholder="https://example.com/stream.m3u8">
+                    <p class="form-help">Sie können die Stream-URL auch später im Dashboard hinzufügen</p>
+                    <?php if (isset($errors['stream_url'])): ?>
+                    <p class="error-text"><?php echo htmlspecialchars($errors['stream_url']); ?></p>
+                    <?php endif; ?>
+                </div>
+
+                <div class="form-group">
+                    <label class="toggle-wrapper">
+                        <input type="checkbox" name="accept_terms" <?php echo !empty($formData['accept_terms']) ? 'checked' : ''; ?> required>
+                        <span class="terms-text">
+                            Ich akzeptiere die <a href="/terms" target="_blank">AGB</a> und
+                            <a href="/privacy" target="_blank">Datenschutzerklärung</a> *
+                        </span>
+                    </label>
+                    <?php if (isset($errors['accept_terms'])): ?>
+                    <p class="error-text"><?php echo htmlspecialchars($errors['accept_terms']); ?></p>
+                    <?php endif; ?>
+                </div>
+
+                <button type="submit" class="btn btn-primary" style="width: 100%; margin-top: 1rem;">
+                    Kostenlos registrieren
+                </button>
+            </form>
+
+            <p style="text-align: center; margin-top: 1.5rem; color: var(--gray-500);">
+                Bereits registriert?
+                <a href="/dashboard/login.php" style="color: var(--primary);">Anmelden</a>
+            </p>
+        </div>
+    </div>
+</body>
+</html>

aurora-livecam/onboarding/stream.php

@@ -0,0 +1,265 @@
+<?php
+/**
+ * Onboarding - Stream Konfiguration (Schritt 3)
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Onboarding\OnboardingManager;
+use AuroraLivecam\Onboarding\StreamValidator;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+
+// Login prüfen
+if (!$auth->isLoggedIn()) {
+    header('Location: /onboarding/register.php');
+    exit;
+}
+
+$user = $auth->getUser();
+$tenantId = $user['tenant_id'] ?? 0;
+
+$error = '';
+$streamUrl = '';
+$streamType = 'hls';
+$validationResult = null;
+
+// Formular verarbeiten
+if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+    $streamUrl = trim($_POST['stream_url'] ?? '');
+    $streamType = $_POST['stream_type'] ?? 'hls';
+
+    if (empty($streamUrl)) {
+        $error = 'Bitte geben Sie eine Stream-URL ein';
+    } else {
+        try {
+            // Stream validieren
+            $validator = new StreamValidator();
+            $validationResult = $validator->validate($streamUrl);
+
+            if ($validationResult['valid']) {
+                // Speichern
+                $onboarding = new OnboardingManager();
+                $result = $onboarding->saveStream($tenantId, $streamUrl, $streamType);
+
+                if ($result['success']) {
+                    header('Location: /onboarding/branding.php');
+                    exit;
+                } else {
+                    $error = $result['error'];
+                }
+            } else {
+                $error = $validationResult['error'] ?? 'Stream-URL konnte nicht validiert werden';
+            }
+        } catch (\Exception $e) {
+            $error = 'Fehler: ' . $e->getMessage();
+        }
+    }
+}
+
+// Skip erlauben
+if (isset($_GET['skip'])) {
+    header('Location: /onboarding/branding.php');
+    exit;
+}
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Stream einrichten - Aurora Livecam</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        .onboarding-container {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+            padding: 2rem;
+        }
+        .onboarding-box {
+            background: var(--white);
+            padding: 2.5rem;
+            border-radius: 1rem;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+            width: 100%;
+            max-width: 600px;
+        }
+        .onboarding-header {
+            text-align: center;
+            margin-bottom: 2rem;
+        }
+        .onboarding-header h1 {
+            font-size: 1.5rem;
+            margin-bottom: 0.5rem;
+        }
+        .progress-steps {
+            display: flex;
+            justify-content: center;
+            gap: 0.5rem;
+            margin-bottom: 1.5rem;
+        }
+        .step {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: var(--gray-300);
+        }
+        .step.active { background: var(--primary); }
+        .step.completed { background: var(--success); }
+        .validation-result {
+            margin-top: 1rem;
+            padding: 1rem;
+            border-radius: 0.5rem;
+        }
+        .validation-success {
+            background: #c6f6d5;
+            border: 1px solid #9ae6b4;
+        }
+        .validation-error {
+            background: #fed7d7;
+            border: 1px solid #feb2b2;
+        }
+        .validation-details {
+            font-size: 0.875rem;
+            margin-top: 0.5rem;
+            color: var(--gray-600);
+        }
+        .stream-types {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 1rem;
+            margin-bottom: 1.5rem;
+        }
+        .stream-type-card {
+            border: 2px solid var(--gray-200);
+            border-radius: 0.5rem;
+            padding: 1rem;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        .stream-type-card:hover {
+            border-color: var(--primary);
+        }
+        .stream-type-card.selected {
+            border-color: var(--primary);
+            background: rgba(102, 126, 234, 0.05);
+        }
+        .stream-type-card input {
+            display: none;
+        }
+        .stream-type-card h4 {
+            margin: 0 0 0.25rem 0;
+            font-size: 1rem;
+        }
+        .stream-type-card p {
+            margin: 0;
+            font-size: 0.75rem;
+            color: var(--gray-500);
+        }
+        .skip-link {
+            display: block;
+            text-align: center;
+            margin-top: 1.5rem;
+            color: var(--gray-500);
+            font-size: 0.875rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="onboarding-container">
+        <div class="onboarding-box">
+            <div class="progress-steps">
+                <div class="step completed"></div>
+                <div class="step completed"></div>
+                <div class="step active"></div>
+                <div class="step"></div>
+            </div>
+
+            <div class="onboarding-header">
+                <h1>📹 Stream einrichten</h1>
+                <p style="color: var(--gray-500);">Verbinden Sie Ihre Webcam oder Ihren Stream</p>
+            </div>
+
+            <?php if ($error): ?>
+            <div class="alert alert-error"><?php echo htmlspecialchars($error); ?></div>
+            <?php endif; ?>
+
+            <form method="POST" action="" id="stream-form">
+                <div class="form-group">
+                    <label class="form-label">Stream-Typ wählen</label>
+                    <div class="stream-types">
+                        <label class="stream-type-card <?php echo $streamType === 'hls' ? 'selected' : ''; ?>">
+                            <input type="radio" name="stream_type" value="hls" <?php echo $streamType === 'hls' ? 'checked' : ''; ?>>
+                            <h4>🎬 HLS Stream</h4>
+                            <p>.m3u8 Playlist (empfohlen)</p>
+                        </label>
+                        <label class="stream-type-card <?php echo $streamType === 'rtmp' ? 'selected' : ''; ?>">
+                            <input type="radio" name="stream_type" value="rtmp" <?php echo $streamType === 'rtmp' ? 'checked' : ''; ?>>
+                            <h4>📡 RTMP</h4>
+                            <p>Real-Time Messaging Protocol</p>
+                        </label>
+                        <label class="stream-type-card <?php echo $streamType === 'iframe' ? 'selected' : ''; ?>">
+                            <input type="radio" name="stream_type" value="iframe" <?php echo $streamType === 'iframe' ? 'checked' : ''; ?>>
+                            <h4>🖼️ Embed</h4>
+                            <p>YouTube, Vimeo, Twitch</p>
+                        </label>
+                        <label class="stream-type-card <?php echo $streamType === 'webrtc' ? 'selected' : ''; ?>">
+                            <input type="radio" name="stream_type" value="webrtc" <?php echo $streamType === 'webrtc' ? 'checked' : ''; ?>>
+                            <h4>⚡ WebRTC</h4>
+                            <p>Ultra-niedrige Latenz</p>
+                        </label>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label" for="stream_url">Stream-URL</label>
+                    <input type="url" id="stream_url" name="stream_url" class="form-input"
+                           value="<?php echo htmlspecialchars($streamUrl); ?>"
+                           placeholder="https://example.com/stream.m3u8" required>
+                    <p class="form-help">Die vollständige URL zu Ihrem Stream</p>
+                </div>
+
+                <?php if ($validationResult): ?>
+                <div class="validation-result <?php echo $validationResult['valid'] ? 'validation-success' : 'validation-error'; ?>">
+                    <strong><?php echo $validationResult['valid'] ? '✓ Stream erreichbar' : '✗ Stream nicht erreichbar'; ?></strong>
+                    <?php if (!empty($validationResult['details'])): ?>
+                    <div class="validation-details">
+                        <?php if (isset($validationResult['details']['detected_type'])): ?>
+                        Erkannter Typ: <?php echo htmlspecialchars($validationResult['details']['detected_type']); ?>
+                        <?php endif; ?>
+                    </div>
+                    <?php endif; ?>
+                </div>
+                <?php endif; ?>
+
+                <button type="submit" class="btn btn-primary" style="width: 100%; margin-top: 1.5rem;">
+                    Stream testen & weiter
+                </button>
+            </form>
+
+            <a href="?skip=1" class="skip-link">
+                Später einrichten →
+            </a>
+        </div>
+    </div>
+
+    <script>
+    document.querySelectorAll('.stream-type-card').forEach(card => {
+        card.addEventListener('click', () => {
+            document.querySelectorAll('.stream-type-card').forEach(c => c.classList.remove('selected'));
+            card.classList.add('selected');
+        });
+    });
+    </script>
+</body>
+</html>

aurora-livecam/onboarding/verify.php

@@ -0,0 +1,214 @@
+<?php
+/**
+ * Onboarding - E-Mail Verifizierung
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/SettingsManager.php';
+
+if (file_exists(dirname(__DIR__) . '/src/bootstrap.php')) {
+    require_once dirname(__DIR__) . '/src/bootstrap.php';
+}
+
+use AuroraLivecam\Auth\AuthManager;
+use AuroraLivecam\Onboarding\OnboardingManager;
+
+$settingsManager = new SettingsManager();
+$auth = new AuthManager();
+
+// Login prüfen
+if (!$auth->isLoggedIn()) {
+    header('Location: /onboarding/register.php');
+    exit;
+}
+
+$user = $auth->getUser();
+$message = '';
+$error = '';
+$verified = false;
+
+// Token aus URL verarbeiten
+if (isset($_GET['token'])) {
+    try {
+        $onboarding = new OnboardingManager();
+        $result = $onboarding->verifyEmail($_GET['token']);
+
+        if ($result['success']) {
+            $verified = true;
+            $message = 'E-Mail erfolgreich verifiziert!';
+        } else {
+            $error = $result['error'];
+        }
+    } catch (\Exception $e) {
+        $error = 'Verifikation fehlgeschlagen';
+    }
+}
+
+// E-Mail erneut senden
+if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['resend'])) {
+    try {
+        $onboarding = new OnboardingManager();
+        $result = $onboarding->resendVerification($user['id']);
+
+        if ($result['success']) {
+            $_SESSION['verification_token'] = $result['token'];
+            $message = 'Verifikations-E-Mail wurde erneut gesendet!';
+        } else {
+            $error = $result['error'];
+        }
+    } catch (\Exception $e) {
+        $error = 'Fehler beim Senden';
+    }
+}
+
+// Demo: Token anzeigen (in Produktion würde eine E-Mail gesendet)
+$demoToken = $_SESSION['verification_token'] ?? null;
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>E-Mail verifizieren - Aurora Livecam</title>
+    <link rel="stylesheet" href="/dashboard/assets/dashboard.css">
+    <style>
+        .verify-container {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
+            padding: 2rem;
+        }
+        .verify-box {
+            background: var(--white);
+            padding: 2.5rem;
+            border-radius: 1rem;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+            width: 100%;
+            max-width: 500px;
+            text-align: center;
+        }
+        .verify-icon {
+            font-size: 4rem;
+            margin-bottom: 1rem;
+        }
+        .verify-box h1 {
+            font-size: 1.5rem;
+            margin-bottom: 1rem;
+        }
+        .verify-box p {
+            color: var(--gray-600);
+            margin-bottom: 1.5rem;
+        }
+        .email-highlight {
+            font-weight: 600;
+            color: var(--gray-800);
+        }
+        .demo-box {
+            background: var(--gray-100);
+            border: 1px dashed var(--gray-300);
+            border-radius: 0.5rem;
+            padding: 1rem;
+            margin: 1.5rem 0;
+            text-align: left;
+        }
+        .demo-box h4 {
+            font-size: 0.875rem;
+            color: var(--warning);
+            margin-bottom: 0.5rem;
+        }
+        .demo-link {
+            word-break: break-all;
+            font-family: monospace;
+            font-size: 0.75rem;
+            background: white;
+            padding: 0.5rem;
+            border-radius: 0.25rem;
+            display: block;
+            margin-top: 0.5rem;
+        }
+        .progress-steps {
+            display: flex;
+            justify-content: center;
+            gap: 0.5rem;
+            margin-bottom: 2rem;
+        }
+        .step {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: var(--gray-300);
+        }
+        .step.active {
+            background: var(--primary);
+        }
+        .step.completed {
+            background: var(--success);
+        }
+    </style>
+</head>
+<body>
+    <div class="verify-container">
+        <div class="verify-box">
+            <div class="progress-steps">
+                <div class="step completed"></div>
+                <div class="step active"></div>
+                <div class="step"></div>
+                <div class="step"></div>
+            </div>
+
+            <?php if ($verified): ?>
+            <div class="verify-icon">✅</div>
+            <h1>E-Mail verifiziert!</h1>
+            <p>Ihre E-Mail-Adresse wurde erfolgreich bestätigt.</p>
+            <a href="/onboarding/stream.php" class="btn btn-primary" style="width: 100%;">
+                Weiter zur Stream-Konfiguration
+            </a>
+            <?php else: ?>
+            <div class="verify-icon">📧</div>
+            <h1>E-Mail bestätigen</h1>
+            <p>
+                Wir haben eine Bestätigungs-E-Mail an<br>
+                <span class="email-highlight"><?php echo htmlspecialchars($user['email'] ?? ''); ?></span><br>
+                gesendet.
+            </p>
+
+            <?php if ($message): ?>
+            <div class="alert alert-success"><?php echo htmlspecialchars($message); ?></div>
+            <?php endif; ?>
+
+            <?php if ($error): ?>
+            <div class="alert alert-error"><?php echo htmlspecialchars($error); ?></div>
+            <?php endif; ?>
+
+            <?php if ($demoToken): ?>
+            <div class="demo-box">
+                <h4>⚠️ Demo-Modus</h4>
+                <p style="font-size: 0.875rem; margin: 0;">In der Produktion würde eine E-Mail gesendet. Für Demo-Zwecke:</p>
+                <a href="/onboarding/verify.php?token=<?php echo urlencode($demoToken); ?>" class="demo-link">
+                    Klicken Sie hier um zu verifizieren
+                </a>
+            </div>
+            <?php endif; ?>
+
+            <p style="margin-top: 1.5rem; color: var(--gray-500); font-size: 0.875rem;">
+                Keine E-Mail erhalten?
+            </p>
+
+            <form method="POST" action="" style="display: inline;">
+                <button type="submit" name="resend" class="btn btn-secondary">
+                    Erneut senden
+                </button>
+            </form>
+            <?php endif; ?>
+
+            <p style="margin-top: 2rem;">
+                <a href="/dashboard/logout.php" style="color: var(--gray-500); font-size: 0.875rem;">
+                    Abmelden
+                </a>
+            </p>
+        </div>
+    </div>
+</body>
+</html>

aurora-livecam/settings.json

@@ -0,0 +1,71 @@
+{
+    "viewer_display": {
+        "enabled": true,
+        "min_viewers": 1,
+        "update_interval": 5
+    },
+    "video_mode": {
+        "play_in_player": true,
+        "allow_download": true
+    },
+    "timelapse": {
+        "default_speed": 1,
+        "available_speeds": [
+            1,
+            10,
+            100
+        ]
+    },
+    "ui_display": {
+        "show_recommendation_banner": true,
+        "show_qr_code": true,
+        "show_social_media": true,
+        "show_patrouille_suisse": true
+    },
+    "zoom_timelapse": {
+        "show_zoom_controls": true,
+        "max_zoom_level": 4.0,
+        "timelapse_reverse_enabled": true,
+        "weekly_timelapse_enabled": true
+    },
+    "auto_screenshot": {
+        "enabled": false,
+        "interval_minutes": 10,
+        "max_images": 144,
+        "save_to_gallery": true
+    },
+    "sharing": {
+        "email_enabled": false,
+        "share_link_expiry_hours": 24
+    },
+    "content": {
+        "guestbook_enabled": true,
+        "gallery_enabled": true,
+        "ai_events_enabled": true,
+        "max_guestbook_entries": 50
+    },
+    "technical": {
+        "viewer_update_interval": 5,
+        "session_timeout": 30
+    },
+    "theme": {
+        "default_theme": "theme-legacy",
+        "show_theme_switcher": false
+    },
+    "seo": {
+        "custom_title": "",
+        "meta_description": "",
+        "meta_keywords": ""
+    },
+    "weather": {
+        "enabled": true,
+        "api_key": "",
+        "location": "Oberdürnten,CH",
+        "lat": "47.2833",
+        "lon": "8.7167",
+        "update_interval": 5,
+        "units": "metric"
+    },
+    "last_updated": null,
+    "updated_by": null
+}

aurora-livecam/src/Auth/AuthManager.php

@@ -0,0 +1,355 @@
+<?php
+/**
+ * AuthManager - Sichere Authentifizierung für Dashboard
+ */
+
+namespace AuroraLivecam\Auth;
+
+use AuroraLivecam\Core\Database;
+
+class AuthManager
+{
+    private Database $db;
+    private bool $dbAvailable = false;
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+        $this->checkDbAvailability();
+
+        if (session_status() === PHP_SESSION_NONE) {
+            session_start();
+        }
+    }
+
+    private function checkDbAvailability(): void
+    {
+        try {
+            $this->db->fetchOne("SELECT 1 FROM users LIMIT 1");
+            $this->dbAvailable = true;
+        } catch (\Exception $e) {
+            $this->dbAvailable = false;
+        }
+    }
+
+    /**
+     * Registriert einen neuen Benutzer
+     */
+    public function register(array $data): int
+    {
+        if (!$this->dbAvailable) {
+            throw new \Exception('Database not available');
+        }
+
+        // Validierung
+        if (empty($data['email']) || !filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
+            throw new \Exception('Invalid email address');
+        }
+
+        if (empty($data['password']) || strlen($data['password']) < 8) {
+            throw new \Exception('Password must be at least 8 characters');
+        }
+
+        // Prüfe ob Email bereits existiert
+        $existing = $this->db->fetchOne("SELECT id FROM users WHERE email = ?", [$data['email']]);
+        if ($existing) {
+            throw new \Exception('Email already registered');
+        }
+
+        // Benutzer erstellen
+        return $this->db->insert('users', [
+            'tenant_id' => $data['tenant_id'] ?? null,
+            'email' => strtolower($data['email']),
+            'password_hash' => password_hash($data['password'], PASSWORD_ARGON2ID),
+            'name' => $data['name'] ?? null,
+            'role' => $data['role'] ?? 'tenant_user',
+        ]);
+    }
+
+    /**
+     * Login mit Email und Passwort
+     */
+    public function login(string $email, string $password, bool $remember = false): bool
+    {
+        // Legacy-Modus (hardcoded admin)
+        if (!$this->dbAvailable) {
+            return $this->legacyLogin($email, $password);
+        }
+
+        $user = $this->db->fetchOne(
+            "SELECT u.*, t.name as tenant_name, t.slug as tenant_slug
+             FROM users u
+             LEFT JOIN tenants t ON u.tenant_id = t.id
+             WHERE u.email = ?",
+            [strtolower($email)]
+        );
+
+        if (!$user || !password_verify($password, $user['password_hash'])) {
+            return false;
+        }
+
+        // Session setzen
+        $this->setSession($user);
+
+        // Last login aktualisieren
+        $this->db->update('users', ['last_login_at' => date('Y-m-d H:i:s')], 'id = ?', [$user['id']]);
+
+        // Remember-Me Cookie
+        if ($remember) {
+            $this->setRememberToken($user['id']);
+        }
+
+        return true;
+    }
+
+    /**
+     * Legacy Login (kompatibel mit altem AdminManager)
+     */
+    private function legacyLogin(string $email, string $password): bool
+    {
+        // Alte hardcoded Credentials als Fallback
+        if ($email === 'admin' && $password === 'sonne4000$$$$Q') {
+            $_SESSION['admin'] = true;
+            $_SESSION['user'] = [
+                'id' => 0,
+                'email' => 'admin',
+                'name' => 'Administrator',
+                'role' => 'super_admin',
+                'tenant_id' => null,
+            ];
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Setzt die Session-Daten
+     */
+    private function setSession(array $user): void
+    {
+        $_SESSION['admin'] = true; // Kompatibilität mit Legacy
+        $_SESSION['user'] = [
+            'id' => $user['id'],
+            'email' => $user['email'],
+            'name' => $user['name'],
+            'role' => $user['role'],
+            'tenant_id' => $user['tenant_id'],
+            'tenant_name' => $user['tenant_name'] ?? null,
+            'tenant_slug' => $user['tenant_slug'] ?? null,
+        ];
+    }
+
+    /**
+     * Setzt Remember-Me Token
+     */
+    private function setRememberToken(int $userId): void
+    {
+        $token = bin2hex(random_bytes(32));
+        $hashedToken = hash('sha256', $token);
+
+        $this->db->update('users', ['remember_token' => $hashedToken], 'id = ?', [$userId]);
+
+        setcookie('remember_token', $token, [
+            'expires' => time() + (86400 * 30), // 30 Tage
+            'path' => '/',
+            'secure' => true,
+            'httponly' => true,
+            'samesite' => 'Lax'
+        ]);
+    }
+
+    /**
+     * Prüft Remember-Me Cookie
+     */
+    public function checkRememberToken(): bool
+    {
+        if (!isset($_COOKIE['remember_token']) || !$this->dbAvailable) {
+            return false;
+        }
+
+        $hashedToken = hash('sha256', $_COOKIE['remember_token']);
+
+        $user = $this->db->fetchOne(
+            "SELECT u.*, t.name as tenant_name, t.slug as tenant_slug
+             FROM users u
+             LEFT JOIN tenants t ON u.tenant_id = t.id
+             WHERE u.remember_token = ?",
+            [$hashedToken]
+        );
+
+        if ($user) {
+            $this->setSession($user);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Logout
+     */
+    public function logout(): void
+    {
+        // Remember-Token löschen
+        if ($this->isLoggedIn() && $this->dbAvailable) {
+            $userId = $_SESSION['user']['id'] ?? 0;
+            if ($userId > 0) {
+                $this->db->update('users', ['remember_token' => null], 'id = ?', [$userId]);
+            }
+        }
+
+        // Cookie löschen
+        setcookie('remember_token', '', [
+            'expires' => time() - 3600,
+            'path' => '/',
+            'secure' => true,
+            'httponly' => true,
+        ]);
+
+        // Session zerstören
+        $_SESSION = [];
+        if (ini_get("session.use_cookies")) {
+            $params = session_get_cookie_params();
+            setcookie(session_name(), '', time() - 42000,
+                $params["path"], $params["domain"],
+                $params["secure"], $params["httponly"]
+            );
+        }
+        session_destroy();
+    }
+
+    /**
+     * Prüft ob User eingeloggt ist
+     */
+    public function isLoggedIn(): bool
+    {
+        return isset($_SESSION['admin']) && $_SESSION['admin'] === true;
+    }
+
+    /**
+     * Gibt den aktuellen User zurück
+     */
+    public function getUser(): ?array
+    {
+        return $_SESSION['user'] ?? null;
+    }
+
+    /**
+     * Prüft ob User eine bestimmte Rolle hat
+     */
+    public function hasRole(string $role): bool
+    {
+        $user = $this->getUser();
+        return $user && $user['role'] === $role;
+    }
+
+    /**
+     * Prüft ob User Super-Admin ist
+     */
+    public function isSuperAdmin(): bool
+    {
+        return $this->hasRole('super_admin');
+    }
+
+    /**
+     * Prüft ob User Tenant-Admin ist
+     */
+    public function isTenantAdmin(): bool
+    {
+        return $this->hasRole('tenant_admin') || $this->hasRole('super_admin');
+    }
+
+    /**
+     * Gibt die Tenant-ID des aktuellen Users zurück
+     */
+    public function getTenantId(): ?int
+    {
+        $user = $this->getUser();
+        return $user ? ($user['tenant_id'] ?? null) : null;
+    }
+
+    /**
+     * Prüft ob User Zugriff auf einen bestimmten Tenant hat
+     */
+    public function canAccessTenant(int $tenantId): bool
+    {
+        if ($this->isSuperAdmin()) {
+            return true;
+        }
+
+        return $this->getTenantId() === $tenantId;
+    }
+
+    /**
+     * Ändert das Passwort
+     */
+    public function changePassword(int $userId, string $currentPassword, string $newPassword): bool
+    {
+        if (!$this->dbAvailable) {
+            return false;
+        }
+
+        $user = $this->db->fetchOne("SELECT password_hash FROM users WHERE id = ?", [$userId]);
+
+        if (!$user || !password_verify($currentPassword, $user['password_hash'])) {
+            return false;
+        }
+
+        if (strlen($newPassword) < 8) {
+            throw new \Exception('Password must be at least 8 characters');
+        }
+
+        return $this->db->update('users', [
+            'password_hash' => password_hash($newPassword, PASSWORD_ARGON2ID)
+        ], 'id = ?', [$userId]) > 0;
+    }
+
+    /**
+     * Generiert ein Passwort-Reset-Token
+     */
+    public function generateResetToken(string $email): ?string
+    {
+        if (!$this->dbAvailable) {
+            return null;
+        }
+
+        $user = $this->db->fetchOne("SELECT id FROM users WHERE email = ?", [strtolower($email)]);
+
+        if (!$user) {
+            return null; // Keine Info leaken ob Email existiert
+        }
+
+        $token = bin2hex(random_bytes(32));
+        // Token würde normalerweise in separater Tabelle mit Ablaufzeit gespeichert
+        // Für jetzt: vereinfachte Version
+
+        return $token;
+    }
+
+    /**
+     * Middleware: Erfordert Login
+     */
+    public function requireLogin(): void
+    {
+        if (!$this->isLoggedIn()) {
+            if (!$this->checkRememberToken()) {
+                header('Location: /dashboard/login.php');
+                exit;
+            }
+        }
+    }
+
+    /**
+     * Middleware: Erfordert bestimmte Rolle
+     */
+    public function requireRole(string $role): void
+    {
+        $this->requireLogin();
+
+        if (!$this->hasRole($role) && !$this->isSuperAdmin()) {
+            http_response_code(403);
+            echo "Access denied";
+            exit;
+        }
+    }
+}

aurora-livecam/src/Billing/StripeService.php

@@ -0,0 +1,290 @@
+<?php
+/**
+ * StripeService - Stripe API Wrapper
+ */
+
+namespace AuroraLivecam\Billing;
+
+use AuroraLivecam\Core\Database;
+
+class StripeService
+{
+    private ?string $secretKey;
+    private ?string $publicKey;
+    private ?string $webhookSecret;
+    private string $currency;
+    private Database $db;
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+        $this->loadConfig();
+    }
+
+    /**
+     * Lädt Stripe-Konfiguration
+     */
+    private function loadConfig(): void
+    {
+        $configFile = dirname(__DIR__, 2) . '/config.php';
+
+        if (file_exists($configFile)) {
+            $config = require $configFile;
+            $this->secretKey = $config['stripe']['secret_key'] ?? '';
+            $this->publicKey = $config['stripe']['public_key'] ?? '';
+            $this->webhookSecret = $config['stripe']['webhook_secret'] ?? '';
+            $this->currency = $config['stripe']['currency'] ?? 'chf';
+        } else {
+            $this->secretKey = getenv('STRIPE_SECRET_KEY') ?: '';
+            $this->publicKey = getenv('STRIPE_PUBLIC_KEY') ?: '';
+            $this->webhookSecret = getenv('STRIPE_WEBHOOK_SECRET') ?: '';
+            $this->currency = 'chf';
+        }
+    }
+
+    /**
+     * Prüft ob Stripe konfiguriert ist
+     */
+    public function isConfigured(): bool
+    {
+        return !empty($this->secretKey) && !empty($this->publicKey);
+    }
+
+    /**
+     * Gibt den Public Key zurück
+     */
+    public function getPublicKey(): string
+    {
+        return $this->publicKey ?? '';
+    }
+
+    /**
+     * Erstellt einen Stripe Customer
+     */
+    public function createCustomer(int $tenantId, string $email, string $name): ?string
+    {
+        $response = $this->request('POST', '/v1/customers', [
+            'email' => $email,
+            'name' => $name,
+            'metadata' => [
+                'tenant_id' => $tenantId,
+            ],
+        ]);
+
+        if ($response && isset($response['id'])) {
+            // In DB speichern
+            $this->db->execute(
+                "UPDATE subscriptions SET stripe_customer_id = ? WHERE tenant_id = ?",
+                [$response['id'], $tenantId]
+            );
+            return $response['id'];
+        }
+
+        return null;
+    }
+
+    /**
+     * Erstellt eine Checkout Session
+     */
+    public function createCheckoutSession(int $tenantId, string $priceId, string $successUrl, string $cancelUrl): ?array
+    {
+        // Customer ID holen oder erstellen
+        $customerId = $this->getOrCreateCustomer($tenantId);
+
+        $params = [
+            'customer' => $customerId,
+            'payment_method_types' => ['card'],
+            'line_items' => [[
+                'price' => $priceId,
+                'quantity' => 1,
+            ]],
+            'mode' => 'subscription',
+            'success_url' => $successUrl,
+            'cancel_url' => $cancelUrl,
+            'metadata' => [
+                'tenant_id' => $tenantId,
+            ],
+        ];
+
+        return $this->request('POST', '/v1/checkout/sessions', $params);
+    }
+
+    /**
+     * Erstellt ein Billing Portal Session
+     */
+    public function createPortalSession(int $tenantId, string $returnUrl): ?array
+    {
+        $customerId = $this->getCustomerId($tenantId);
+
+        if (!$customerId) {
+            return null;
+        }
+
+        return $this->request('POST', '/v1/billing_portal/sessions', [
+            'customer' => $customerId,
+            'return_url' => $returnUrl,
+        ]);
+    }
+
+    /**
+     * Holt oder erstellt Customer
+     */
+    private function getOrCreateCustomer(int $tenantId): ?string
+    {
+        $customerId = $this->getCustomerId($tenantId);
+
+        if ($customerId) {
+            return $customerId;
+        }
+
+        // Tenant-Daten laden
+        $tenant = $this->db->fetchOne(
+            "SELECT t.*, u.email, u.name FROM tenants t
+             LEFT JOIN users u ON u.tenant_id = t.id AND u.role = 'tenant_admin'
+             WHERE t.id = ? LIMIT 1",
+            [$tenantId]
+        );
+
+        if (!$tenant) {
+            return null;
+        }
+
+        return $this->createCustomer($tenantId, $tenant['email'], $tenant['name'] ?? $tenant['name']);
+    }
+
+    /**
+     * Holt Customer ID aus DB
+     */
+    private function getCustomerId(int $tenantId): ?string
+    {
+        $sub = $this->db->fetchOne(
+            "SELECT stripe_customer_id FROM subscriptions WHERE tenant_id = ?",
+            [$tenantId]
+        );
+
+        return $sub['stripe_customer_id'] ?? null;
+    }
+
+    /**
+     * Holt Subscription von Stripe
+     */
+    public function getSubscription(string $subscriptionId): ?array
+    {
+        return $this->request('GET', '/v1/subscriptions/' . $subscriptionId);
+    }
+
+    /**
+     * Kündigt Subscription
+     */
+    public function cancelSubscription(string $subscriptionId, bool $immediately = false): ?array
+    {
+        if ($immediately) {
+            return $this->request('DELETE', '/v1/subscriptions/' . $subscriptionId);
+        }
+
+        return $this->request('POST', '/v1/subscriptions/' . $subscriptionId, [
+            'cancel_at_period_end' => true,
+        ]);
+    }
+
+    /**
+     * Holt Rechnungen
+     */
+    public function getInvoices(string $customerId, int $limit = 10): array
+    {
+        $response = $this->request('GET', '/v1/invoices', [
+            'customer' => $customerId,
+            'limit' => $limit,
+        ]);
+
+        return $response['data'] ?? [];
+    }
+
+    /**
+     * Verifiziert Webhook-Signatur
+     */
+    public function verifyWebhook(string $payload, string $signature): ?array
+    {
+        if (empty($this->webhookSecret)) {
+            return json_decode($payload, true);
+        }
+
+        $elements = explode(',', $signature);
+        $timestamp = null;
+        $signatures = [];
+
+        foreach ($elements as $element) {
+            $parts = explode('=', $element, 2);
+            if ($parts[0] === 't') {
+                $timestamp = $parts[1];
+            } elseif ($parts[0] === 'v1') {
+                $signatures[] = $parts[1];
+            }
+        }
+
+        if (!$timestamp || empty($signatures)) {
+            return null;
+        }
+
+        // Toleranz: 5 Minuten
+        if (abs(time() - $timestamp) > 300) {
+            return null;
+        }
+
+        $signedPayload = $timestamp . '.' . $payload;
+        $expectedSignature = hash_hmac('sha256', $signedPayload, $this->webhookSecret);
+
+        foreach ($signatures as $sig) {
+            if (hash_equals($expectedSignature, $sig)) {
+                return json_decode($payload, true);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Stripe API Request
+     */
+    private function request(string $method, string $endpoint, array $data = []): ?array
+    {
+        if (!$this->isConfigured()) {
+            return null;
+        }
+
+        $url = 'https://api.stripe.com' . $endpoint;
+
+        $ch = curl_init();
+
+        $headers = [
+            'Authorization: Bearer ' . $this->secretKey,
+            'Content-Type: application/x-www-form-urlencoded',
+        ];
+
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url . ($method === 'GET' && $data ? '?' . http_build_query($data) : ''),
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_HTTPHEADER => $headers,
+            CURLOPT_TIMEOUT => 30,
+        ]);
+
+        if ($method === 'POST') {
+            curl_setopt($ch, CURLOPT_POST, true);
+            curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data));
+        } elseif ($method === 'DELETE') {
+            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
+        }
+
+        $response = curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        if ($httpCode >= 200 && $httpCode < 300) {
+            return json_decode($response, true);
+        }
+
+        // Log error
+        error_log("Stripe API Error ($httpCode): $response");
+        return null;
+    }
+}

aurora-livecam/src/Billing/SubscriptionManager.php

@@ -0,0 +1,285 @@
+<?php
+/**
+ * SubscriptionManager - Verwaltet Subscriptions
+ */
+
+namespace AuroraLivecam\Billing;
+
+use AuroraLivecam\Core\Database;
+
+class SubscriptionManager
+{
+    private Database $db;
+    private StripeService $stripe;
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+        $this->stripe = new StripeService($this->db);
+    }
+
+    /**
+     * Gibt alle Pläne zurück
+     */
+    public function getPlans(bool $activeOnly = true): array
+    {
+        $sql = "SELECT * FROM plans";
+        if ($activeOnly) {
+            $sql .= " WHERE is_active = 1";
+        }
+        $sql .= " ORDER BY sort_order ASC";
+
+        $plans = $this->db->fetchAll($sql);
+
+        // Features JSON decodieren
+        foreach ($plans as &$plan) {
+            if (isset($plan['features'])) {
+                $plan['features'] = json_decode($plan['features'], true) ?? [];
+            }
+        }
+
+        return $plans;
+    }
+
+    /**
+     * Gibt einen Plan zurück
+     */
+    public function getPlan(int $planId): ?array
+    {
+        $plan = $this->db->fetchOne("SELECT * FROM plans WHERE id = ?", [$planId]);
+
+        if ($plan && isset($plan['features'])) {
+            $plan['features'] = json_decode($plan['features'], true) ?? [];
+        }
+
+        return $plan;
+    }
+
+    /**
+     * Gibt Plan by Slug zurück
+     */
+    public function getPlanBySlug(string $slug): ?array
+    {
+        $plan = $this->db->fetchOne("SELECT * FROM plans WHERE slug = ?", [$slug]);
+
+        if ($plan && isset($plan['features'])) {
+            $plan['features'] = json_decode($plan['features'], true) ?? [];
+        }
+
+        return $plan;
+    }
+
+    /**
+     * Gibt die aktuelle Subscription eines Tenants zurück
+     */
+    public function getSubscription(int $tenantId): ?array
+    {
+        $sub = $this->db->fetchOne(
+            "SELECT s.*, p.name as plan_name, p.slug as plan_slug, p.features as plan_features
+             FROM subscriptions s
+             JOIN plans p ON s.plan_id = p.id
+             WHERE s.tenant_id = ?
+             ORDER BY s.created_at DESC LIMIT 1",
+            [$tenantId]
+        );
+
+        if ($sub && isset($sub['plan_features'])) {
+            $sub['plan_features'] = json_decode($sub['plan_features'], true) ?? [];
+        }
+
+        return $sub;
+    }
+
+    /**
+     * Erstellt oder aktualisiert eine Subscription
+     */
+    public function createOrUpdate(int $tenantId, array $data): int
+    {
+        $existing = $this->db->fetchOne(
+            "SELECT id FROM subscriptions WHERE tenant_id = ?",
+            [$tenantId]
+        );
+
+        if ($existing) {
+            $this->db->update('subscriptions', $data, 'id = ?', [$existing['id']]);
+            return $existing['id'];
+        }
+
+        $data['tenant_id'] = $tenantId;
+        return $this->db->insert('subscriptions', $data);
+    }
+
+    /**
+     * Startet Trial für einen Tenant
+     */
+    public function startTrial(int $tenantId, int $planId = null, int $days = 14): void
+    {
+        if (!$planId) {
+            $freePlan = $this->getPlanBySlug('basic');
+            $planId = $freePlan['id'] ?? 1;
+        }
+
+        $this->createOrUpdate($tenantId, [
+            'plan_id' => $planId,
+            'status' => 'trialing',
+            'current_period_start' => date('Y-m-d H:i:s'),
+            'current_period_end' => date('Y-m-d H:i:s', strtotime("+$days days")),
+        ]);
+
+        // Tenant Status
+        $this->db->update('tenants', [
+            'status' => 'trial',
+            'trial_ends_at' => date('Y-m-d H:i:s', strtotime("+$days days")),
+        ], 'id = ?', [$tenantId]);
+    }
+
+    /**
+     * Aktiviert Subscription nach Zahlung
+     */
+    public function activate(int $tenantId, string $stripeSubscriptionId, int $planId): void
+    {
+        $this->createOrUpdate($tenantId, [
+            'plan_id' => $planId,
+            'stripe_subscription_id' => $stripeSubscriptionId,
+            'status' => 'active',
+            'current_period_start' => date('Y-m-d H:i:s'),
+        ]);
+
+        $this->db->update('tenants', ['status' => 'active', 'plan_id' => $planId], 'id = ?', [$tenantId]);
+    }
+
+    /**
+     * Kündigt Subscription
+     */
+    public function cancel(int $tenantId, bool $immediately = false): bool
+    {
+        $sub = $this->getSubscription($tenantId);
+
+        if (!$sub) {
+            return false;
+        }
+
+        // Bei Stripe kündigen
+        if (!empty($sub['stripe_subscription_id'])) {
+            $this->stripe->cancelSubscription($sub['stripe_subscription_id'], $immediately);
+        }
+
+        $status = $immediately ? 'canceled' : 'active'; // Bleibt aktiv bis Periodenende
+
+        $this->db->update('subscriptions', [
+            'status' => $status,
+            'canceled_at' => date('Y-m-d H:i:s'),
+        ], 'tenant_id = ?', [$tenantId]);
+
+        if ($immediately) {
+            $this->db->update('tenants', ['status' => 'cancelled'], 'id = ?', [$tenantId]);
+        }
+
+        return true;
+    }
+
+    /**
+     * Prüft ob Tenant aktiv ist (Trial oder bezahlt)
+     */
+    public function isActive(int $tenantId): bool
+    {
+        $sub = $this->getSubscription($tenantId);
+
+        if (!$sub) {
+            return false;
+        }
+
+        if ($sub['status'] === 'active') {
+            return true;
+        }
+
+        if ($sub['status'] === 'trialing') {
+            $endDate = strtotime($sub['current_period_end']);
+            return $endDate > time();
+        }
+
+        return false;
+    }
+
+    /**
+     * Gibt verbleibende Trial-Tage zurück
+     */
+    public function getTrialDaysRemaining(int $tenantId): int
+    {
+        $tenant = $this->db->fetchOne(
+            "SELECT trial_ends_at FROM tenants WHERE id = ?",
+            [$tenantId]
+        );
+
+        if (!$tenant || !$tenant['trial_ends_at']) {
+            return 0;
+        }
+
+        $remaining = strtotime($tenant['trial_ends_at']) - time();
+        return max(0, (int)ceil($remaining / 86400));
+    }
+
+    /**
+     * Prüft Feature-Zugriff
+     */
+    public function hasFeature(int $tenantId, string $feature): bool
+    {
+        $sub = $this->getSubscription($tenantId);
+
+        if (!$sub || !isset($sub['plan_features'])) {
+            return false;
+        }
+
+        return !empty($sub['plan_features'][$feature]);
+    }
+
+    /**
+     * Gibt Feature-Limit zurück
+     */
+    public function getFeatureLimit(int $tenantId, string $feature): int
+    {
+        $sub = $this->getSubscription($tenantId);
+
+        if (!$sub || !isset($sub['plan_features'][$feature])) {
+            return 0;
+        }
+
+        $value = $sub['plan_features'][$feature];
+
+        // -1 = unlimited
+        if ($value === -1 || $value === true) {
+            return PHP_INT_MAX;
+        }
+
+        return (int)$value;
+    }
+
+    /**
+     * Speichert Rechnung
+     */
+    public function saveInvoice(int $tenantId, array $invoiceData): void
+    {
+        $this->db->insert('invoices', [
+            'tenant_id' => $tenantId,
+            'stripe_invoice_id' => $invoiceData['id'] ?? null,
+            'amount' => ($invoiceData['amount_paid'] ?? 0) / 100,
+            'currency' => strtoupper($invoiceData['currency'] ?? 'CHF'),
+            'status' => $invoiceData['status'] ?? 'unknown',
+            'paid_at' => isset($invoiceData['status_transitions']['paid_at'])
+                ? date('Y-m-d H:i:s', $invoiceData['status_transitions']['paid_at'])
+                : null,
+            'invoice_pdf_url' => $invoiceData['invoice_pdf'] ?? null,
+        ]);
+    }
+
+    /**
+     * Gibt Rechnungen eines Tenants zurück
+     */
+    public function getInvoices(int $tenantId, int $limit = 10): array
+    {
+        return $this->db->fetchAll(
+            "SELECT * FROM invoices WHERE tenant_id = ? ORDER BY created_at DESC LIMIT ?",
+            [$tenantId, $limit]
+        );
+    }
+}

aurora-livecam/src/Billing/WebhookHandler.php

@@ -0,0 +1,250 @@
+<?php
+/**
+ * WebhookHandler - Verarbeitet Stripe Webhooks
+ */
+
+namespace AuroraLivecam\Billing;
+
+use AuroraLivecam\Core\Database;
+
+class WebhookHandler
+{
+    private Database $db;
+    private StripeService $stripe;
+    private SubscriptionManager $subscriptions;
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+        $this->stripe = new StripeService($this->db);
+        $this->subscriptions = new SubscriptionManager($this->db);
+    }
+
+    /**
+     * Verarbeitet einen Webhook
+     */
+    public function handle(string $payload, string $signature): array
+    {
+        // Signatur verifizieren
+        $event = $this->stripe->verifyWebhook($payload, $signature);
+
+        if (!$event) {
+            return ['success' => false, 'error' => 'Invalid signature'];
+        }
+
+        $type = $event['type'] ?? '';
+        $data = $event['data']['object'] ?? [];
+
+        try {
+            switch ($type) {
+                case 'checkout.session.completed':
+                    return $this->handleCheckoutComplete($data);
+
+                case 'customer.subscription.created':
+                case 'customer.subscription.updated':
+                    return $this->handleSubscriptionUpdate($data);
+
+                case 'customer.subscription.deleted':
+                    return $this->handleSubscriptionDeleted($data);
+
+                case 'invoice.paid':
+                    return $this->handleInvoicePaid($data);
+
+                case 'invoice.payment_failed':
+                    return $this->handlePaymentFailed($data);
+
+                default:
+                    return ['success' => true, 'message' => 'Event ignored: ' . $type];
+            }
+        } catch (\Exception $e) {
+            error_log("Webhook error: " . $e->getMessage());
+            return ['success' => false, 'error' => $e->getMessage()];
+        }
+    }
+
+    /**
+     * Checkout abgeschlossen
+     */
+    private function handleCheckoutComplete(array $session): array
+    {
+        $tenantId = $session['metadata']['tenant_id'] ?? null;
+        $subscriptionId = $session['subscription'] ?? null;
+
+        if (!$tenantId || !$subscriptionId) {
+            return ['success' => false, 'error' => 'Missing tenant_id or subscription'];
+        }
+
+        // Subscription-Details von Stripe holen
+        $subscription = $this->stripe->getSubscription($subscriptionId);
+
+        if (!$subscription) {
+            return ['success' => false, 'error' => 'Could not fetch subscription'];
+        }
+
+        // Plan aus Stripe Price ID ermitteln
+        $priceId = $subscription['items']['data'][0]['price']['id'] ?? null;
+        $plan = $this->db->fetchOne(
+            "SELECT id FROM plans WHERE stripe_price_id = ?",
+            [$priceId]
+        );
+
+        $planId = $plan['id'] ?? 1;
+
+        // Subscription aktivieren
+        $this->subscriptions->activate($tenantId, $subscriptionId, $planId);
+
+        // Customer ID speichern
+        $this->db->update('subscriptions', [
+            'stripe_customer_id' => $session['customer'],
+        ], 'tenant_id = ?', [$tenantId]);
+
+        return ['success' => true, 'message' => 'Subscription activated'];
+    }
+
+    /**
+     * Subscription erstellt/aktualisiert
+     */
+    private function handleSubscriptionUpdate(array $subscription): array
+    {
+        $customerId = $subscription['customer'] ?? null;
+
+        if (!$customerId) {
+            return ['success' => false, 'error' => 'No customer ID'];
+        }
+
+        // Tenant über Customer ID finden
+        $sub = $this->db->fetchOne(
+            "SELECT tenant_id FROM subscriptions WHERE stripe_customer_id = ?",
+            [$customerId]
+        );
+
+        if (!$sub) {
+            return ['success' => true, 'message' => 'Customer not found in DB'];
+        }
+
+        $tenantId = $sub['tenant_id'];
+        $status = $this->mapStripeStatus($subscription['status']);
+
+        $this->db->update('subscriptions', [
+            'stripe_subscription_id' => $subscription['id'],
+            'status' => $status,
+            'current_period_start' => date('Y-m-d H:i:s', $subscription['current_period_start']),
+            'current_period_end' => date('Y-m-d H:i:s', $subscription['current_period_end']),
+        ], 'tenant_id = ?', [$tenantId]);
+
+        // Tenant-Status aktualisieren
+        $tenantStatus = in_array($status, ['active', 'trialing']) ? 'active' : 'suspended';
+        $this->db->update('tenants', ['status' => $tenantStatus], 'id = ?', [$tenantId]);
+
+        return ['success' => true, 'message' => 'Subscription updated'];
+    }
+
+    /**
+     * Subscription gelöscht/gekündigt
+     */
+    private function handleSubscriptionDeleted(array $subscription): array
+    {
+        $customerId = $subscription['customer'] ?? null;
+
+        if (!$customerId) {
+            return ['success' => false, 'error' => 'No customer ID'];
+        }
+
+        $sub = $this->db->fetchOne(
+            "SELECT tenant_id FROM subscriptions WHERE stripe_customer_id = ?",
+            [$customerId]
+        );
+
+        if (!$sub) {
+            return ['success' => true, 'message' => 'Customer not found'];
+        }
+
+        $this->db->update('subscriptions', [
+            'status' => 'canceled',
+            'canceled_at' => date('Y-m-d H:i:s'),
+        ], 'tenant_id = ?', [$sub['tenant_id']]);
+
+        // Downgrade zu Free-Plan
+        $freePlan = $this->db->fetchOne("SELECT id FROM plans WHERE slug = 'free'");
+        if ($freePlan) {
+            $this->db->update('tenants', [
+                'status' => 'active',
+                'plan_id' => $freePlan['id'],
+            ], 'id = ?', [$sub['tenant_id']]);
+        }
+
+        return ['success' => true, 'message' => 'Subscription canceled'];
+    }
+
+    /**
+     * Rechnung bezahlt
+     */
+    private function handleInvoicePaid(array $invoice): array
+    {
+        $customerId = $invoice['customer'] ?? null;
+
+        if (!$customerId) {
+            return ['success' => false, 'error' => 'No customer ID'];
+        }
+
+        $sub = $this->db->fetchOne(
+            "SELECT tenant_id FROM subscriptions WHERE stripe_customer_id = ?",
+            [$customerId]
+        );
+
+        if (!$sub) {
+            return ['success' => true, 'message' => 'Customer not found'];
+        }
+
+        // Rechnung speichern
+        $this->subscriptions->saveInvoice($sub['tenant_id'], $invoice);
+
+        return ['success' => true, 'message' => 'Invoice saved'];
+    }
+
+    /**
+     * Zahlung fehlgeschlagen
+     */
+    private function handlePaymentFailed(array $invoice): array
+    {
+        $customerId = $invoice['customer'] ?? null;
+
+        if (!$customerId) {
+            return ['success' => false, 'error' => 'No customer ID'];
+        }
+
+        $sub = $this->db->fetchOne(
+            "SELECT tenant_id FROM subscriptions WHERE stripe_customer_id = ?",
+            [$customerId]
+        );
+
+        if (!$sub) {
+            return ['success' => true, 'message' => 'Customer not found'];
+        }
+
+        // Status auf past_due setzen
+        $this->db->update('subscriptions', ['status' => 'past_due'], 'tenant_id = ?', [$sub['tenant_id']]);
+
+        // TODO: E-Mail an Tenant senden
+
+        return ['success' => true, 'message' => 'Payment failure recorded'];
+    }
+
+    /**
+     * Mappt Stripe-Status auf DB-Status
+     */
+    private function mapStripeStatus(string $stripeStatus): string
+    {
+        $map = [
+            'active' => 'active',
+            'trialing' => 'trialing',
+            'past_due' => 'past_due',
+            'canceled' => 'canceled',
+            'unpaid' => 'unpaid',
+            'incomplete' => 'incomplete',
+            'incomplete_expired' => 'canceled',
+        ];
+
+        return $map[$stripeStatus] ?? 'unknown';
+    }
+}

aurora-livecam/src/Core/Database.php

@@ -0,0 +1,215 @@
+<?php
+/**
+ * Database - PDO Wrapper mit Singleton Pattern
+ *
+ * Verwendung:
+ *   $db = Database::getInstance();
+ *   $users = $db->fetchAll("SELECT * FROM users WHERE tenant_id = ?", [$tenantId]);
+ */
+
+namespace AuroraLivecam\Core;
+
+use PDO;
+use PDOException;
+use Exception;
+
+class Database
+{
+    private static ?Database $instance = null;
+    private ?PDO $pdo = null;
+    private array $config;
+
+    private function __construct()
+    {
+        $this->config = $this->loadConfig();
+    }
+
+    /**
+     * Singleton: Gibt die einzige Instanz zurück
+     */
+    public static function getInstance(): Database
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
+    /**
+     * Lädt die Datenbank-Konfiguration
+     */
+    private function loadConfig(): array
+    {
+        // Versuche .env oder config.php zu laden
+        $configFile = dirname(__DIR__, 2) . '/config.php';
+
+        if (file_exists($configFile)) {
+            $config = require $configFile;
+            return $config['database'] ?? [];
+        }
+
+        // Fallback auf Umgebungsvariablen
+        return [
+            'host' => getenv('DB_HOST') ?: 'localhost',
+            'port' => getenv('DB_PORT') ?: 3306,
+            'database' => getenv('DB_DATABASE') ?: 'aurora_livecam',
+            'username' => getenv('DB_USERNAME') ?: 'root',
+            'password' => getenv('DB_PASSWORD') ?: '',
+            'charset' => 'utf8mb4',
+        ];
+    }
+
+    /**
+     * Stellt die Datenbankverbindung her (Lazy Loading)
+     */
+    public function connect(): PDO
+    {
+        if ($this->pdo !== null) {
+            return $this->pdo;
+        }
+
+        $dsn = sprintf(
+            'mysql:host=%s;port=%d;dbname=%s;charset=%s',
+            $this->config['host'],
+            $this->config['port'],
+            $this->config['database'],
+            $this->config['charset']
+        );
+
+        try {
+            $this->pdo = new PDO($dsn, $this->config['username'], $this->config['password'], [
+                PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
+                PDO::ATTR_EMULATE_PREPARES => false,
+                PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci"
+            ]);
+        } catch (PDOException $e) {
+            throw new Exception('Database connection failed: ' . $e->getMessage());
+        }
+
+        return $this->pdo;
+    }
+
+    /**
+     * Führt eine Query aus und gibt alle Ergebnisse zurück
+     */
+    public function fetchAll(string $sql, array $params = []): array
+    {
+        $stmt = $this->connect()->prepare($sql);
+        $stmt->execute($params);
+        return $stmt->fetchAll();
+    }
+
+    /**
+     * Führt eine Query aus und gibt eine Zeile zurück
+     */
+    public function fetchOne(string $sql, array $params = []): ?array
+    {
+        $stmt = $this->connect()->prepare($sql);
+        $stmt->execute($params);
+        $result = $stmt->fetch();
+        return $result ?: null;
+    }
+
+    /**
+     * Führt eine Query aus und gibt einen einzelnen Wert zurück
+     */
+    public function fetchColumn(string $sql, array $params = [], int $column = 0): mixed
+    {
+        $stmt = $this->connect()->prepare($sql);
+        $stmt->execute($params);
+        return $stmt->fetchColumn($column);
+    }
+
+    /**
+     * Führt INSERT/UPDATE/DELETE aus und gibt die Anzahl betroffener Zeilen zurück
+     */
+    public function execute(string $sql, array $params = []): int
+    {
+        $stmt = $this->connect()->prepare($sql);
+        $stmt->execute($params);
+        return $stmt->rowCount();
+    }
+
+    /**
+     * INSERT und gibt die neue ID zurück
+     */
+    public function insert(string $table, array $data): int
+    {
+        $columns = implode(', ', array_map(fn($col) => "`$col`", array_keys($data)));
+        $placeholders = implode(', ', array_fill(0, count($data), '?'));
+
+        $sql = "INSERT INTO `$table` ($columns) VALUES ($placeholders)";
+        $this->execute($sql, array_values($data));
+
+        return (int) $this->connect()->lastInsertId();
+    }
+
+    /**
+     * UPDATE mit WHERE-Bedingung
+     */
+    public function update(string $table, array $data, string $where, array $whereParams = []): int
+    {
+        $set = implode(', ', array_map(fn($col) => "`$col` = ?", array_keys($data)));
+        $sql = "UPDATE `$table` SET $set WHERE $where";
+
+        return $this->execute($sql, [...array_values($data), ...$whereParams]);
+    }
+
+    /**
+     * DELETE mit WHERE-Bedingung
+     */
+    public function delete(string $table, string $where, array $params = []): int
+    {
+        return $this->execute("DELETE FROM `$table` WHERE $where", $params);
+    }
+
+    /**
+     * Startet eine Transaktion
+     */
+    public function beginTransaction(): bool
+    {
+        return $this->connect()->beginTransaction();
+    }
+
+    /**
+     * Bestätigt eine Transaktion
+     */
+    public function commit(): bool
+    {
+        return $this->connect()->commit();
+    }
+
+    /**
+     * Macht eine Transaktion rückgängig
+     */
+    public function rollback(): bool
+    {
+        return $this->connect()->rollBack();
+    }
+
+    /**
+     * Prüft ob eine Datenbankverbindung besteht
+     */
+    public function isConnected(): bool
+    {
+        return $this->pdo !== null;
+    }
+
+    /**
+     * Gibt die PDO-Instanz direkt zurück (für komplexe Queries)
+     */
+    public function getPdo(): PDO
+    {
+        return $this->connect();
+    }
+
+    // Prevent cloning
+    private function __clone() {}
+
+    // Prevent unserialization
+    public function __wakeup()
+    {
+        throw new Exception("Cannot unserialize singleton");
+    }
+}

aurora-livecam/src/Core/TenantResolver.php

@@ -0,0 +1,316 @@
+<?php
+/**
+ * TenantResolver - Ermittelt den aktuellen Tenant basierend auf Domain
+ *
+ * Ersetzt den hardcoded Domain-Switch in index.php
+ */
+
+namespace AuroraLivecam\Core;
+
+class TenantResolver
+{
+    private Database $db;
+    private ?array $currentTenant = null;
+    private ?array $currentBranding = null;
+    private static ?TenantResolver $instance = null;
+
+    // Cache für Domain-Lookups (vermeidet DB-Anfragen bei jedem Request)
+    private static array $domainCache = [];
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+    }
+
+    /**
+     * Singleton für globalen Zugriff
+     */
+    public static function getInstance(): TenantResolver
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
+    /**
+     * Löst die aktuelle Domain auf und gibt den Tenant zurück
+     */
+    public function resolve(?string $domain = null): ?array
+    {
+        $domain = $domain ?? $this->getCurrentDomain();
+
+        if ($this->currentTenant !== null && ($this->currentTenant['domain'] ?? '') === $domain) {
+            return $this->currentTenant;
+        }
+
+        // Cache prüfen
+        if (isset(self::$domainCache[$domain])) {
+            $this->currentTenant = self::$domainCache[$domain];
+            return $this->currentTenant;
+        }
+
+        // Aus DB laden
+        $this->currentTenant = $this->loadTenantByDomain($domain);
+
+        // In Cache speichern
+        self::$domainCache[$domain] = $this->currentTenant;
+
+        return $this->currentTenant;
+    }
+
+    /**
+     * Lädt einen Tenant anhand der Domain aus der Datenbank
+     */
+    private function loadTenantByDomain(string $domain): ?array
+    {
+        // Normalisiere Domain (ohne www.)
+        $normalizedDomain = $this->normalizeDomain($domain);
+
+        try {
+            $sql = "
+                SELECT
+                    t.*,
+                    td.domain,
+                    td.is_primary,
+                    p.name as plan_name,
+                    p.slug as plan_slug,
+                    p.features as plan_features
+                FROM tenant_domains td
+                JOIN tenants t ON td.tenant_id = t.id
+                LEFT JOIN plans p ON t.plan_id = p.id
+                WHERE td.domain = ? OR td.domain = ?
+                LIMIT 1
+            ";
+
+            $tenant = $this->db->fetchOne($sql, [$domain, $normalizedDomain]);
+
+            if ($tenant && isset($tenant['plan_features'])) {
+                $tenant['plan_features'] = json_decode($tenant['plan_features'], true);
+            }
+
+            return $tenant;
+        } catch (\Exception $e) {
+            // Fallback: Keine DB-Verbindung oder Tabelle existiert nicht
+            return $this->getFallbackTenant($domain);
+        }
+    }
+
+    /**
+     * Fallback für Legacy-Modus (ohne Datenbank)
+     * Unterstützt die alten hardcoded Domains
+     */
+    private function getFallbackTenant(string $domain): ?array
+    {
+        $normalizedDomain = $this->normalizeDomain($domain);
+
+        // Alte seecam.ch Konfiguration
+        if (str_contains($normalizedDomain, 'seecam.ch')) {
+            return [
+                'id' => 0,
+                'uuid' => 'legacy-seecam',
+                'name' => 'Seecam',
+                'slug' => 'seecam',
+                'status' => 'active',
+                'domain' => $domain,
+                'is_legacy' => true,
+                'branding' => [
+                    'site_name' => 'Seecam',
+                    'site_name_full' => 'Seecam.ch - Live Webcam',
+                    'tagline' => 'Ihre Live-Webcam',
+                    'primary_color' => '#667eea',
+                    'secondary_color' => '#764ba2',
+                ],
+            ];
+        }
+
+        // Default: Aurora
+        if (str_contains($normalizedDomain, 'aurora') ||
+            str_contains($normalizedDomain, 'localhost') ||
+            $normalizedDomain === '127.0.0.1') {
+            return [
+                'id' => 0,
+                'uuid' => 'legacy-aurora',
+                'name' => 'Aurora Weather Livecam',
+                'slug' => 'aurora',
+                'status' => 'active',
+                'domain' => $domain,
+                'is_legacy' => true,
+                'branding' => [
+                    'site_name' => 'Aurora',
+                    'site_name_full' => 'Aurora Weather Livecam - Zürich Oberland',
+                    'tagline' => 'Wetter Webcam Schweiz',
+                    'primary_color' => '#667eea',
+                    'secondary_color' => '#764ba2',
+                ],
+            ];
+        }
+
+        // Unbekannte Domain - Default Tenant
+        return [
+            'id' => 0,
+            'uuid' => 'default',
+            'name' => 'Livecam',
+            'slug' => 'default',
+            'status' => 'active',
+            'domain' => $domain,
+            'is_legacy' => true,
+            'branding' => [
+                'site_name' => 'Livecam',
+                'site_name_full' => 'Livecam',
+                'primary_color' => '#667eea',
+                'secondary_color' => '#764ba2',
+            ],
+        ];
+    }
+
+    /**
+     * Gibt das Branding des aktuellen Tenants zurück
+     */
+    public function getBranding(): array
+    {
+        if ($this->currentBranding !== null) {
+            return $this->currentBranding;
+        }
+
+        $tenant = $this->resolve();
+
+        if (!$tenant) {
+            return $this->getDefaultBranding();
+        }
+
+        // Legacy-Tenant hat Branding inline
+        if (isset($tenant['is_legacy']) && $tenant['is_legacy']) {
+            $this->currentBranding = $tenant['branding'] ?? $this->getDefaultBranding();
+            return $this->currentBranding;
+        }
+
+        // Aus DB laden
+        try {
+            $branding = $this->db->fetchOne(
+                "SELECT * FROM tenant_branding WHERE tenant_id = ?",
+                [$tenant['id']]
+            );
+
+            $this->currentBranding = $branding ?: $this->getDefaultBranding();
+        } catch (\Exception $e) {
+            $this->currentBranding = $this->getDefaultBranding();
+        }
+
+        return $this->currentBranding;
+    }
+
+    /**
+     * Default Branding
+     */
+    private function getDefaultBranding(): array
+    {
+        return [
+            'site_name' => 'Livecam',
+            'site_name_full' => 'Live Webcam',
+            'tagline' => '',
+            'logo_path' => null,
+            'favicon_path' => null,
+            'primary_color' => '#667eea',
+            'secondary_color' => '#764ba2',
+            'accent_color' => '#f093fb',
+            'welcome_text_de' => '',
+            'welcome_text_en' => '',
+            'footer_text' => '',
+            'custom_css' => '',
+        ];
+    }
+
+    /**
+     * Gibt die aktuelle Domain zurück
+     */
+    public function getCurrentDomain(): string
+    {
+        return $_SERVER['HTTP_HOST'] ?? 'localhost';
+    }
+
+    /**
+     * Normalisiert eine Domain (entfernt www.)
+     */
+    private function normalizeDomain(string $domain): string
+    {
+        return preg_replace('/^www\./i', '', strtolower($domain));
+    }
+
+    /**
+     * Prüft ob der aktuelle Tenant aktiv ist
+     */
+    public function isActive(): bool
+    {
+        $tenant = $this->resolve();
+        return $tenant && in_array($tenant['status'], ['active', 'trial']);
+    }
+
+    /**
+     * Prüft ob der Tenant im Trial ist
+     */
+    public function isTrial(): bool
+    {
+        $tenant = $this->resolve();
+        return $tenant && $tenant['status'] === 'trial';
+    }
+
+    /**
+     * Gibt die Tenant-ID zurück (oder 0 für Legacy)
+     */
+    public function getTenantId(): int
+    {
+        $tenant = $this->resolve();
+        return $tenant['id'] ?? 0;
+    }
+
+    /**
+     * Gibt den Tenant-Slug zurück
+     */
+    public function getTenantSlug(): string
+    {
+        $tenant = $this->resolve();
+        return $tenant['slug'] ?? 'default';
+    }
+
+    /**
+     * Prüft ob Multi-Tenant-Modus aktiv ist (DB vorhanden)
+     */
+    public function isMultiTenantEnabled(): bool
+    {
+        $tenant = $this->resolve();
+        return $tenant && !isset($tenant['is_legacy']);
+    }
+
+    /**
+     * Gibt alle Domains eines Tenants zurück
+     */
+    public function getTenantDomains(int $tenantId): array
+    {
+        try {
+            return $this->db->fetchAll(
+                "SELECT * FROM tenant_domains WHERE tenant_id = ? ORDER BY is_primary DESC",
+                [$tenantId]
+            );
+        } catch (\Exception $e) {
+            return [];
+        }
+    }
+
+    /**
+     * Setzt den aktuellen Tenant manuell (für Tests oder CLI)
+     */
+    public function setTenant(array $tenant): void
+    {
+        $this->currentTenant = $tenant;
+        $this->currentBranding = null;
+    }
+
+    /**
+     * Leert den Cache
+     */
+    public static function clearCache(): void
+    {
+        self::$domainCache = [];
+    }
+}

aurora-livecam/src/Onboarding/OnboardingManager.php

@@ -0,0 +1,366 @@
+<?php
+/**
+ * OnboardingManager - Verwaltet den Onboarding-Prozess
+ */
+
+namespace AuroraLivecam\Onboarding;
+
+use AuroraLivecam\Core\Database;
+use AuroraLivecam\Tenant\TenantManager;
+use AuroraLivecam\Auth\AuthManager;
+
+class OnboardingManager
+{
+    private Database $db;
+    private TenantManager $tenantManager;
+    private StreamValidator $streamValidator;
+
+    public const STEP_REGISTER = 1;
+    public const STEP_VERIFY_EMAIL = 2;
+    public const STEP_STREAM = 3;
+    public const STEP_BRANDING = 4;
+    public const STEP_COMPLETE = 5;
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+        $this->tenantManager = new TenantManager($this->db);
+        $this->streamValidator = new StreamValidator();
+    }
+
+    /**
+     * Startet den Onboarding-Prozess (Registrierung)
+     */
+    public function register(array $data): array
+    {
+        $errors = $this->validateRegistration($data);
+
+        if (!empty($errors)) {
+            return ['success' => false, 'errors' => $errors];
+        }
+
+        try {
+            $this->db->beginTransaction();
+
+            // Tenant erstellen
+            $tenantId = $this->tenantManager->create([
+                'name' => $data['company_name'] ?? $data['name'],
+                'email' => $data['email'],
+                'subdomain' => $this->generateSubdomain($data['company_name'] ?? $data['name']),
+                'stream_url' => $data['stream_url'] ?? '',
+                'stream_type' => $data['stream_type'] ?? 'hls',
+            ]);
+
+            // Admin-User für den Tenant erstellen
+            $auth = new AuthManager($this->db);
+            $userId = $auth->register([
+                'tenant_id' => $tenantId,
+                'email' => $data['email'],
+                'password' => $data['password'],
+                'name' => $data['name'],
+                'role' => 'tenant_admin',
+            ]);
+
+            // Verification-Token generieren
+            $verificationToken = $this->generateVerificationToken($userId);
+
+            $this->db->commit();
+
+            return [
+                'success' => true,
+                'tenant_id' => $tenantId,
+                'user_id' => $userId,
+                'verification_token' => $verificationToken,
+                'next_step' => self::STEP_VERIFY_EMAIL,
+            ];
+
+        } catch (\Exception $e) {
+            $this->db->rollback();
+            return ['success' => false, 'errors' => ['general' => $e->getMessage()]];
+        }
+    }
+
+    /**
+     * Validiert Registrierungsdaten
+     */
+    private function validateRegistration(array $data): array
+    {
+        $errors = [];
+
+        // Name
+        if (empty($data['name'])) {
+            $errors['name'] = 'Name ist erforderlich';
+        }
+
+        // Company/Site Name
+        if (empty($data['company_name'])) {
+            $errors['company_name'] = 'Firmen-/Site-Name ist erforderlich';
+        }
+
+        // Email
+        if (empty($data['email'])) {
+            $errors['email'] = 'E-Mail ist erforderlich';
+        } elseif (!filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
+            $errors['email'] = 'Ungültige E-Mail-Adresse';
+        } else {
+            // Prüfe ob Email bereits existiert
+            $existing = $this->db->fetchOne("SELECT id FROM users WHERE email = ?", [strtolower($data['email'])]);
+            if ($existing) {
+                $errors['email'] = 'Diese E-Mail-Adresse ist bereits registriert';
+            }
+        }
+
+        // Password
+        if (empty($data['password'])) {
+            $errors['password'] = 'Passwort ist erforderlich';
+        } elseif (strlen($data['password']) < 8) {
+            $errors['password'] = 'Passwort muss mindestens 8 Zeichen lang sein';
+        }
+
+        // Password Confirmation
+        if (($data['password'] ?? '') !== ($data['password_confirm'] ?? '')) {
+            $errors['password_confirm'] = 'Passwörter stimmen nicht überein';
+        }
+
+        // Stream URL (optional, aber wenn angegeben, validieren)
+        if (!empty($data['stream_url'])) {
+            $validation = $this->streamValidator->validate($data['stream_url']);
+            if (!$validation['valid']) {
+                $errors['stream_url'] = $validation['error'] ?? 'Stream-URL ungültig';
+            }
+        }
+
+        // Terms
+        if (empty($data['accept_terms'])) {
+            $errors['accept_terms'] = 'Sie müssen die AGB akzeptieren';
+        }
+
+        return $errors;
+    }
+
+    /**
+     * Generiert eine Subdomain aus dem Firmennamen
+     */
+    private function generateSubdomain(string $name): string
+    {
+        // Umlaute ersetzen
+        $replacements = ['ä' => 'ae', 'ö' => 'oe', 'ü' => 'ue', 'ß' => 'ss'];
+        $slug = str_replace(array_keys($replacements), array_values($replacements), strtolower($name));
+
+        // Nur alphanumerische Zeichen und Bindestriche
+        $slug = preg_replace('/[^a-z0-9]+/', '-', $slug);
+        $slug = trim($slug, '-');
+
+        // Max 30 Zeichen
+        $slug = substr($slug, 0, 30);
+
+        // Eindeutigkeit prüfen
+        $baseSlug = $slug;
+        $counter = 1;
+        while (!$this->tenantManager->isDomainAvailable($slug . '.aurora-livecam.com')) {
+            $slug = $baseSlug . '-' . $counter;
+            $counter++;
+        }
+
+        return $slug;
+    }
+
+    /**
+     * Generiert einen E-Mail-Verification-Token
+     */
+    private function generateVerificationToken(int $userId): string
+    {
+        $token = bin2hex(random_bytes(32));
+
+        // Token in einer separaten Tabelle speichern (oder im User)
+        // Vereinfacht: Wir nutzen remember_token temporär
+        $this->db->update('users', ['remember_token' => hash('sha256', $token)], 'id = ?', [$userId]);
+
+        return $token;
+    }
+
+    /**
+     * Verifiziert E-Mail-Adresse
+     */
+    public function verifyEmail(string $token): array
+    {
+        $hashedToken = hash('sha256', $token);
+
+        $user = $this->db->fetchOne(
+            "SELECT id, tenant_id FROM users WHERE remember_token = ? AND email_verified_at IS NULL",
+            [$hashedToken]
+        );
+
+        if (!$user) {
+            return ['success' => false, 'error' => 'Ungültiger oder abgelaufener Token'];
+        }
+
+        $this->db->update('users', [
+            'email_verified_at' => date('Y-m-d H:i:s'),
+            'remember_token' => null,
+        ], 'id = ?', [$user['id']]);
+
+        // Onboarding-Status aktualisieren
+        $this->updateOnboardingStep($user['tenant_id'], self::STEP_STREAM);
+
+        return [
+            'success' => true,
+            'user_id' => $user['id'],
+            'tenant_id' => $user['tenant_id'],
+            'next_step' => self::STEP_STREAM,
+        ];
+    }
+
+    /**
+     * Speichert Stream-Konfiguration
+     */
+    public function saveStream(int $tenantId, string $url, string $type = 'hls'): array
+    {
+        // Validieren
+        $validation = $this->streamValidator->validate($url);
+
+        if (!$validation['valid']) {
+            return ['success' => false, 'error' => $validation['error']];
+        }
+
+        // Speichern
+        $existing = $this->db->fetchOne(
+            "SELECT id FROM tenant_streams WHERE tenant_id = ? AND is_primary = 1",
+            [$tenantId]
+        );
+
+        if ($existing) {
+            $this->db->update('tenant_streams', [
+                'stream_url' => $url,
+                'stream_type' => $validation['type'] ?? $type,
+                'last_status' => 'online',
+                'last_check_at' => date('Y-m-d H:i:s'),
+            ], 'id = ?', [$existing['id']]);
+        } else {
+            $this->db->insert('tenant_streams', [
+                'tenant_id' => $tenantId,
+                'stream_url' => $url,
+                'stream_type' => $validation['type'] ?? $type,
+                'is_primary' => 1,
+                'last_status' => 'online',
+                'last_check_at' => date('Y-m-d H:i:s'),
+            ]);
+        }
+
+        // Onboarding-Schritt aktualisieren
+        $this->updateOnboardingStep($tenantId, self::STEP_BRANDING, ['stream_verified' => 1]);
+
+        return [
+            'success' => true,
+            'stream_type' => $validation['type'],
+            'next_step' => self::STEP_BRANDING,
+        ];
+    }
+
+    /**
+     * Speichert Basis-Branding
+     */
+    public function saveBranding(int $tenantId, array $branding): array
+    {
+        $this->tenantManager->updateBranding($tenantId, $branding);
+
+        // Onboarding-Schritt aktualisieren
+        $this->updateOnboardingStep($tenantId, self::STEP_COMPLETE, ['branding_configured' => 1]);
+
+        return [
+            'success' => true,
+            'next_step' => self::STEP_COMPLETE,
+        ];
+    }
+
+    /**
+     * Schliesst das Onboarding ab
+     */
+    public function complete(int $tenantId): array
+    {
+        $this->db->update('tenant_onboarding', [
+            'current_step' => self::STEP_COMPLETE,
+            'completed_at' => date('Y-m-d H:i:s'),
+        ], 'tenant_id = ?', [$tenantId]);
+
+        // Tenant aktivieren
+        $this->tenantManager->activate($tenantId);
+
+        return ['success' => true, 'completed' => true];
+    }
+
+    /**
+     * Aktualisiert den Onboarding-Schritt
+     */
+    private function updateOnboardingStep(int $tenantId, int $step, array $extra = []): void
+    {
+        $data = array_merge(['current_step' => $step], $extra);
+        $this->db->update('tenant_onboarding', $data, 'tenant_id = ?', [$tenantId]);
+    }
+
+    /**
+     * Gibt den aktuellen Onboarding-Status zurück
+     */
+    public function getStatus(int $tenantId): array
+    {
+        $onboarding = $this->db->fetchOne(
+            "SELECT * FROM tenant_onboarding WHERE tenant_id = ?",
+            [$tenantId]
+        );
+
+        if (!$onboarding) {
+            return [
+                'current_step' => self::STEP_REGISTER,
+                'completed' => false,
+            ];
+        }
+
+        return [
+            'current_step' => (int)$onboarding['current_step'],
+            'stream_verified' => (bool)$onboarding['stream_verified'],
+            'branding_configured' => (bool)$onboarding['branding_configured'],
+            'payment_configured' => (bool)$onboarding['payment_configured'],
+            'completed' => $onboarding['completed_at'] !== null,
+            'completed_at' => $onboarding['completed_at'],
+        ];
+    }
+
+    /**
+     * Prüft ob E-Mail-Verification erforderlich ist
+     */
+    public function requiresEmailVerification(): bool
+    {
+        // Aus Settings laden
+        $settingsFile = dirname(__DIR__, 2) . '/SettingsManager.php';
+        if (file_exists($settingsFile)) {
+            require_once $settingsFile;
+            $settings = new \SettingsManager();
+            return $settings->get('saas_features.email_verification_required') ?? true;
+        }
+        return true;
+    }
+
+    /**
+     * Sendet Verification-E-Mail erneut
+     */
+    public function resendVerification(int $userId): array
+    {
+        $user = $this->db->fetchOne("SELECT email, email_verified_at FROM users WHERE id = ?", [$userId]);
+
+        if (!$user) {
+            return ['success' => false, 'error' => 'Benutzer nicht gefunden'];
+        }
+
+        if ($user['email_verified_at']) {
+            return ['success' => false, 'error' => 'E-Mail bereits verifiziert'];
+        }
+
+        $token = $this->generateVerificationToken($userId);
+
+        return [
+            'success' => true,
+            'token' => $token,
+            'email' => $user['email'],
+        ];
+    }
+}

aurora-livecam/src/Onboarding/StreamValidator.php

@@ -0,0 +1,263 @@
+<?php
+/**
+ * StreamValidator - Validiert Stream-URLs
+ */
+
+namespace AuroraLivecam\Onboarding;
+
+class StreamValidator
+{
+    private array $supportedTypes = ['hls', 'rtmp', 'webrtc', 'iframe'];
+    private int $timeout = 10;
+
+    /**
+     * Validiert eine Stream-URL
+     */
+    public function validate(string $url): array
+    {
+        $result = [
+            'valid' => false,
+            'type' => null,
+            'error' => null,
+            'details' => [],
+        ];
+
+        // URL-Format prüfen
+        if (!filter_var($url, FILTER_VALIDATE_URL)) {
+            $result['error'] = 'Ungültiges URL-Format';
+            return $result;
+        }
+
+        // Stream-Typ erkennen
+        $type = $this->detectStreamType($url);
+        $result['type'] = $type;
+        $result['details']['detected_type'] = $type;
+
+        // Je nach Typ validieren
+        switch ($type) {
+            case 'hls':
+                return $this->validateHls($url, $result);
+            case 'rtmp':
+                return $this->validateRtmp($url, $result);
+            case 'iframe':
+                return $this->validateIframe($url, $result);
+            default:
+                // Generische HTTP-Prüfung
+                return $this->validateHttp($url, $result);
+        }
+    }
+
+    /**
+     * Erkennt den Stream-Typ anhand der URL
+     */
+    public function detectStreamType(string $url): string
+    {
+        $url = strtolower($url);
+
+        if (str_contains($url, '.m3u8')) {
+            return 'hls';
+        }
+
+        if (str_starts_with($url, 'rtmp://') || str_starts_with($url, 'rtmps://')) {
+            return 'rtmp';
+        }
+
+        if (str_contains($url, 'youtube.com') || str_contains($url, 'youtu.be') ||
+            str_contains($url, 'vimeo.com') || str_contains($url, 'twitch.tv')) {
+            return 'iframe';
+        }
+
+        if (str_contains($url, '.mp4') || str_contains($url, '.webm')) {
+            return 'video';
+        }
+
+        return 'unknown';
+    }
+
+    /**
+     * Validiert HLS-Stream
+     */
+    private function validateHls(string $url, array $result): array
+    {
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_SSL_VERIFYPEER => false,
+            CURLOPT_HTTPHEADER => [
+                'User-Agent: Mozilla/5.0 (compatible; StreamValidator/1.0)'
+            ],
+        ]);
+
+        $response = curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        $contentType = curl_getinfo($ch, CURLINFO_CONTENT_TYPE);
+        $error = curl_error($ch);
+        curl_close($ch);
+
+        $result['details']['http_code'] = $httpCode;
+        $result['details']['content_type'] = $contentType;
+
+        if ($error) {
+            $result['error'] = 'Verbindungsfehler: ' . $error;
+            return $result;
+        }
+
+        if ($httpCode !== 200) {
+            $result['error'] = "HTTP-Fehler: $httpCode";
+            return $result;
+        }
+
+        // Prüfe ob es ein gültiges M3U8 ist
+        if (!str_contains($response, '#EXTM3U')) {
+            $result['error'] = 'Keine gültige HLS-Playlist gefunden';
+            return $result;
+        }
+
+        $result['valid'] = true;
+        $result['details']['is_master'] = str_contains($response, '#EXT-X-STREAM-INF');
+        $result['details']['segments'] = substr_count($response, '#EXTINF');
+
+        return $result;
+    }
+
+    /**
+     * Validiert RTMP-Stream (nur Format-Check)
+     */
+    private function validateRtmp(string $url, array $result): array
+    {
+        // RTMP kann nicht einfach per HTTP geprüft werden
+        // Wir prüfen nur das Format
+
+        $parsed = parse_url($url);
+
+        if (!isset($parsed['host']) || empty($parsed['host'])) {
+            $result['error'] = 'RTMP-URL enthält keinen gültigen Host';
+            return $result;
+        }
+
+        // DNS-Check
+        $ip = gethostbyname($parsed['host']);
+        if ($ip === $parsed['host']) {
+            $result['error'] = 'RTMP-Host nicht erreichbar (DNS-Fehler)';
+            return $result;
+        }
+
+        $result['valid'] = true;
+        $result['details']['host'] = $parsed['host'];
+        $result['details']['note'] = 'RTMP-Streams können erst zur Laufzeit vollständig validiert werden';
+
+        return $result;
+    }
+
+    /**
+     * Validiert iFrame-Embed URL
+     */
+    private function validateIframe(string $url, array $result): array
+    {
+        // Bekannte Embed-Plattformen
+        $embedPatterns = [
+            'youtube' => '/(?:youtube\.com\/(?:embed|watch)|youtu\.be)/i',
+            'vimeo' => '/vimeo\.com/i',
+            'twitch' => '/(?:twitch\.tv|player\.twitch\.tv)/i',
+            'dailymotion' => '/dailymotion\.com/i',
+        ];
+
+        $platform = 'unknown';
+        foreach ($embedPatterns as $name => $pattern) {
+            if (preg_match($pattern, $url)) {
+                $platform = $name;
+                break;
+            }
+        }
+
+        $result['details']['platform'] = $platform;
+
+        // HTTP-Check
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_NOBODY => true, // HEAD request
+            CURLOPT_SSL_VERIFYPEER => false,
+        ]);
+
+        curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        $result['details']['http_code'] = $httpCode;
+
+        if ($httpCode >= 200 && $httpCode < 400) {
+            $result['valid'] = true;
+        } else {
+            $result['error'] = "URL nicht erreichbar (HTTP $httpCode)";
+        }
+
+        return $result;
+    }
+
+    /**
+     * Generische HTTP-Validierung
+     */
+    private function validateHttp(string $url, array $result): array
+    {
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_NOBODY => true,
+            CURLOPT_SSL_VERIFYPEER => false,
+        ]);
+
+        curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        $contentType = curl_getinfo($ch, CURLINFO_CONTENT_TYPE);
+        $error = curl_error($ch);
+        curl_close($ch);
+
+        $result['details']['http_code'] = $httpCode;
+        $result['details']['content_type'] = $contentType;
+
+        if ($error) {
+            $result['error'] = 'Verbindungsfehler: ' . $error;
+            return $result;
+        }
+
+        if ($httpCode >= 200 && $httpCode < 400) {
+            $result['valid'] = true;
+        } else {
+            $result['error'] = "URL nicht erreichbar (HTTP $httpCode)";
+        }
+
+        return $result;
+    }
+
+    /**
+     * Schnelle Erreichbarkeitsprüfung
+     */
+    public function isReachable(string $url): bool
+    {
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_TIMEOUT => 5,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_NOBODY => true,
+            CURLOPT_SSL_VERIFYPEER => false,
+        ]);
+
+        curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        return $httpCode >= 200 && $httpCode < 400;
+    }
+}

aurora-livecam/src/Tenant/TenantManager.php

@@ -0,0 +1,404 @@
+<?php
+/**
+ * TenantManager - CRUD-Operationen für Tenants
+ */
+
+namespace AuroraLivecam\Tenant;
+
+use AuroraLivecam\Core\Database;
+use Exception;
+
+class TenantManager
+{
+    private Database $db;
+
+    public function __construct(?Database $db = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+    }
+
+    /**
+     * Erstellt einen neuen Tenant
+     */
+    public function create(array $data): int
+    {
+        $this->db->beginTransaction();
+
+        try {
+            // UUID generieren
+            $uuid = $this->generateUuid();
+
+            // Slug generieren falls nicht vorhanden
+            $slug = $data['slug'] ?? $this->generateSlug($data['name']);
+
+            // Tenant erstellen
+            $tenantId = $this->db->insert('tenants', [
+                'uuid' => $uuid,
+                'name' => $data['name'],
+                'slug' => $slug,
+                'email' => $data['email'],
+                'status' => $data['status'] ?? 'trial',
+                'plan_id' => $data['plan_id'] ?? $this->getDefaultPlanId(),
+                'trial_ends_at' => $data['trial_ends_at'] ?? $this->calculateTrialEnd(),
+            ]);
+
+            // Domain hinzufügen
+            if (!empty($data['domain'])) {
+                $this->addDomain($tenantId, $data['domain'], true);
+            }
+
+            // Default-Subdomain erstellen
+            if (!empty($data['subdomain'])) {
+                $subdomain = $data['subdomain'] . '.aurora-livecam.com';
+                $this->addDomain($tenantId, $subdomain, empty($data['domain']));
+            }
+
+            // Branding mit Defaults initialisieren
+            $this->db->insert('tenant_branding', [
+                'tenant_id' => $tenantId,
+                'site_name' => $data['name'],
+                'site_name_full' => $data['name'],
+            ]);
+
+            // Onboarding initialisieren
+            $this->db->insert('tenant_onboarding', [
+                'tenant_id' => $tenantId,
+                'current_step' => 1,
+            ]);
+
+            // Stream hinzufügen falls vorhanden
+            if (!empty($data['stream_url'])) {
+                $this->db->insert('tenant_streams', [
+                    'tenant_id' => $tenantId,
+                    'name' => 'Main Stream',
+                    'stream_url' => $data['stream_url'],
+                    'stream_type' => $data['stream_type'] ?? 'hls',
+                    'is_primary' => 1,
+                ]);
+            }
+
+            $this->db->commit();
+
+            return $tenantId;
+
+        } catch (Exception $e) {
+            $this->db->rollback();
+            throw $e;
+        }
+    }
+
+    /**
+     * Aktualisiert einen Tenant
+     */
+    public function update(int $tenantId, array $data): bool
+    {
+        $allowedFields = ['name', 'email', 'status', 'plan_id'];
+        $updateData = array_intersect_key($data, array_flip($allowedFields));
+
+        if (empty($updateData)) {
+            return false;
+        }
+
+        return $this->db->update('tenants', $updateData, 'id = ?', [$tenantId]) > 0;
+    }
+
+    /**
+     * Löscht einen Tenant (Soft-Delete durch Status-Änderung)
+     */
+    public function delete(int $tenantId): bool
+    {
+        return $this->db->update('tenants', ['status' => 'cancelled'], 'id = ?', [$tenantId]) > 0;
+    }
+
+    /**
+     * Hard-Delete (wirklich löschen - Vorsicht!)
+     */
+    public function hardDelete(int $tenantId): bool
+    {
+        return $this->db->delete('tenants', 'id = ?', [$tenantId]) > 0;
+    }
+
+    /**
+     * Gibt einen Tenant anhand der ID zurück
+     */
+    public function getById(int $id): ?array
+    {
+        return $this->db->fetchOne(
+            "SELECT t.*, p.name as plan_name, p.features as plan_features
+             FROM tenants t
+             LEFT JOIN plans p ON t.plan_id = p.id
+             WHERE t.id = ?",
+            [$id]
+        );
+    }
+
+    /**
+     * Gibt einen Tenant anhand des Slugs zurück
+     */
+    public function getBySlug(string $slug): ?array
+    {
+        return $this->db->fetchOne(
+            "SELECT t.*, p.name as plan_name, p.features as plan_features
+             FROM tenants t
+             LEFT JOIN plans p ON t.plan_id = p.id
+             WHERE t.slug = ?",
+            [$slug]
+        );
+    }
+
+    /**
+     * Gibt einen Tenant anhand der UUID zurück
+     */
+    public function getByUuid(string $uuid): ?array
+    {
+        return $this->db->fetchOne(
+            "SELECT t.*, p.name as plan_name, p.features as plan_features
+             FROM tenants t
+             LEFT JOIN plans p ON t.plan_id = p.id
+             WHERE t.uuid = ?",
+            [$uuid]
+        );
+    }
+
+    /**
+     * Listet alle Tenants auf
+     */
+    public function getAll(array $filters = []): array
+    {
+        $sql = "SELECT t.*, p.name as plan_name, p.features as plan_features
+                FROM tenants t
+                LEFT JOIN plans p ON t.plan_id = p.id
+                WHERE 1=1";
+        $params = [];
+
+        if (!empty($filters['status'])) {
+            $sql .= " AND t.status = ?";
+            $params[] = $filters['status'];
+        }
+
+        if (!empty($filters['search'])) {
+            $sql .= " AND (t.name LIKE ? OR t.email LIKE ?)";
+            $params[] = '%' . $filters['search'] . '%';
+            $params[] = '%' . $filters['search'] . '%';
+        }
+
+        $sql .= " ORDER BY t.created_at DESC";
+
+        if (!empty($filters['limit'])) {
+            $sql .= " LIMIT " . (int)$filters['limit'];
+            if (!empty($filters['offset'])) {
+                $sql .= " OFFSET " . (int)$filters['offset'];
+            }
+        }
+
+        return $this->db->fetchAll($sql, $params);
+    }
+
+    /**
+     * Zählt Tenants
+     */
+    public function count(array $filters = []): int
+    {
+        $sql = "SELECT COUNT(*) FROM tenants WHERE 1=1";
+        $params = [];
+
+        if (!empty($filters['status'])) {
+            $sql .= " AND status = ?";
+            $params[] = $filters['status'];
+        }
+
+        return (int) $this->db->fetchColumn($sql, $params);
+    }
+
+    /**
+     * Fügt eine Domain zu einem Tenant hinzu
+     */
+    public function addDomain(int $tenantId, string $domain, bool $isPrimary = false): int
+    {
+        // Normalisiere Domain
+        $domain = strtolower(trim($domain));
+
+        // Prüfe ob Domain bereits existiert
+        $existing = $this->db->fetchOne(
+            "SELECT id FROM tenant_domains WHERE domain = ?",
+            [$domain]
+        );
+
+        if ($existing) {
+            throw new Exception("Domain '$domain' is already in use");
+        }
+
+        // Wenn primary, setze alle anderen auf non-primary
+        if ($isPrimary) {
+            $this->db->execute(
+                "UPDATE tenant_domains SET is_primary = 0 WHERE tenant_id = ?",
+                [$tenantId]
+            );
+        }
+
+        return $this->db->insert('tenant_domains', [
+            'tenant_id' => $tenantId,
+            'domain' => $domain,
+            'is_primary' => $isPrimary ? 1 : 0,
+        ]);
+    }
+
+    /**
+     * Entfernt eine Domain von einem Tenant
+     */
+    public function removeDomain(int $tenantId, string $domain): bool
+    {
+        return $this->db->delete('tenant_domains', 'tenant_id = ? AND domain = ?', [$tenantId, $domain]) > 0;
+    }
+
+    /**
+     * Gibt alle Domains eines Tenants zurück
+     */
+    public function getDomains(int $tenantId): array
+    {
+        return $this->db->fetchAll(
+            "SELECT * FROM tenant_domains WHERE tenant_id = ? ORDER BY is_primary DESC",
+            [$tenantId]
+        );
+    }
+
+    /**
+     * Aktualisiert das Branding eines Tenants
+     */
+    public function updateBranding(int $tenantId, array $data): bool
+    {
+        $allowedFields = [
+            'site_name', 'site_name_full', 'tagline', 'logo_path', 'favicon_path',
+            'primary_color', 'secondary_color', 'accent_color',
+            'welcome_text_de', 'welcome_text_en', 'footer_text',
+            'custom_css', 'custom_js',
+            'social_facebook', 'social_instagram', 'social_youtube'
+        ];
+
+        $updateData = array_intersect_key($data, array_flip($allowedFields));
+
+        if (empty($updateData)) {
+            return false;
+        }
+
+        // Prüfe ob Branding existiert
+        $exists = $this->db->fetchColumn(
+            "SELECT tenant_id FROM tenant_branding WHERE tenant_id = ?",
+            [$tenantId]
+        );
+
+        if ($exists) {
+            return $this->db->update('tenant_branding', $updateData, 'tenant_id = ?', [$tenantId]) > 0;
+        } else {
+            $updateData['tenant_id'] = $tenantId;
+            return $this->db->insert('tenant_branding', $updateData) > 0;
+        }
+    }
+
+    /**
+     * Gibt das Branding eines Tenants zurück
+     */
+    public function getBranding(int $tenantId): ?array
+    {
+        return $this->db->fetchOne(
+            "SELECT * FROM tenant_branding WHERE tenant_id = ?",
+            [$tenantId]
+        );
+    }
+
+    /**
+     * Prüft ob ein Slug verfügbar ist
+     */
+    public function isSlugAvailable(string $slug, ?int $excludeTenantId = null): bool
+    {
+        $sql = "SELECT id FROM tenants WHERE slug = ?";
+        $params = [$slug];
+
+        if ($excludeTenantId) {
+            $sql .= " AND id != ?";
+            $params[] = $excludeTenantId;
+        }
+
+        return $this->db->fetchOne($sql, $params) === null;
+    }
+
+    /**
+     * Prüft ob eine Domain verfügbar ist
+     */
+    public function isDomainAvailable(string $domain, ?int $excludeTenantId = null): bool
+    {
+        $sql = "SELECT td.id FROM tenant_domains td WHERE td.domain = ?";
+        $params = [$domain];
+
+        if ($excludeTenantId) {
+            $sql .= " AND td.tenant_id != ?";
+            $params[] = $excludeTenantId;
+        }
+
+        return $this->db->fetchOne($sql, $params) === null;
+    }
+
+    /**
+     * Generiert einen URL-sicheren Slug aus einem Namen
+     */
+    private function generateSlug(string $name): string
+    {
+        $slug = strtolower($name);
+        $slug = preg_replace('/[^a-z0-9]+/', '-', $slug);
+        $slug = trim($slug, '-');
+
+        // Sicherstellen dass Slug einzigartig ist
+        $baseSlug = $slug;
+        $counter = 1;
+        while (!$this->isSlugAvailable($slug)) {
+            $slug = $baseSlug . '-' . $counter;
+            $counter++;
+        }
+
+        return $slug;
+    }
+
+    /**
+     * Generiert eine UUID v4
+     */
+    private function generateUuid(): string
+    {
+        $data = random_bytes(16);
+        $data[6] = chr(ord($data[6]) & 0x0f | 0x40);
+        $data[8] = chr(ord($data[8]) & 0x3f | 0x80);
+        return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
+    }
+
+    /**
+     * Berechnet das Trial-Ende (14 Tage)
+     */
+    private function calculateTrialEnd(): string
+    {
+        return date('Y-m-d H:i:s', strtotime('+14 days'));
+    }
+
+    /**
+     * Gibt die ID des Default-Plans (Free) zurück
+     */
+    private function getDefaultPlanId(): int
+    {
+        $plan = $this->db->fetchOne("SELECT id FROM plans WHERE slug = 'free' LIMIT 1");
+        return $plan ? (int)$plan['id'] : 1;
+    }
+
+    /**
+     * Aktiviert einen Tenant (z.B. nach Zahlung)
+     */
+    public function activate(int $tenantId): bool
+    {
+        return $this->db->update('tenants', ['status' => 'active'], 'id = ?', [$tenantId]) > 0;
+    }
+
+    /**
+     * Suspendiert einen Tenant (z.B. bei Zahlungsausfall)
+     */
+    public function suspend(int $tenantId): bool
+    {
+        return $this->db->update('tenants', ['status' => 'suspended'], 'id = ?', [$tenantId]) > 0;
+    }
+}

aurora-livecam/src/Tenant/TenantSettingsManager.php

@@ -0,0 +1,427 @@
+<?php
+/**
+ * TenantSettingsManager - DB-basierte Settings pro Tenant
+ *
+ * Erweitert/ersetzt SettingsManager für Multi-Tenant Betrieb
+ * Fällt auf den alten SettingsManager zurück wenn DB nicht verfügbar
+ */
+
+namespace AuroraLivecam\Tenant;
+
+use AuroraLivecam\Core\Database;
+use AuroraLivecam\Core\TenantResolver;
+
+class TenantSettingsManager
+{
+    private Database $db;
+    private TenantResolver $resolver;
+    private int $tenantId;
+    private array $settings = [];
+    private bool $loaded = false;
+    private bool $dbAvailable = false;
+
+    // Fallback auf Legacy-SettingsManager
+    private ?\SettingsManager $legacyManager = null;
+
+    public function __construct(?int $tenantId = null, ?Database $db = null, ?TenantResolver $resolver = null)
+    {
+        $this->db = $db ?? Database::getInstance();
+        $this->resolver = $resolver ?? TenantResolver::getInstance();
+        $this->tenantId = $tenantId ?? $this->resolver->getTenantId();
+
+        $this->checkDbAvailability();
+    }
+
+    /**
+     * Prüft ob die DB verfügbar ist
+     */
+    private function checkDbAvailability(): void
+    {
+        try {
+            $this->db->fetchOne("SELECT 1 FROM tenant_settings LIMIT 1");
+            $this->dbAvailable = true;
+        } catch (\Exception $e) {
+            $this->dbAvailable = false;
+        }
+    }
+
+    /**
+     * Lädt alle Settings für den Tenant
+     */
+    private function load(): void
+    {
+        if ($this->loaded) {
+            return;
+        }
+
+        // Wenn keine DB, nutze Legacy
+        if (!$this->dbAvailable || $this->tenantId === 0) {
+            $this->loadFromLegacy();
+            return;
+        }
+
+        $rows = $this->db->fetchAll(
+            "SELECT setting_key, setting_value FROM tenant_settings WHERE tenant_id = ?",
+            [$this->tenantId]
+        );
+
+        foreach ($rows as $row) {
+            $value = $row['setting_value'];
+            // JSON-Werte parsen
+            if ($value !== null && ($value[0] === '{' || $value[0] === '[')) {
+                $decoded = json_decode($value, true);
+                if (json_last_error() === JSON_ERROR_NONE) {
+                    $value = $decoded;
+                }
+            }
+            // Booleans und Zahlen konvertieren
+            elseif ($value === 'true') $value = true;
+            elseif ($value === 'false') $value = false;
+            elseif (is_numeric($value)) $value = strpos($value, '.') !== false ? (float)$value : (int)$value;
+
+            $this->settings[$row['setting_key']] = $value;
+        }
+
+        // Defaults für fehlende Keys
+        $this->settings = array_merge($this->getDefaults(), $this->settings);
+        $this->loaded = true;
+    }
+
+    /**
+     * Fallback auf Legacy SettingsManager
+     */
+    private function loadFromLegacy(): void
+    {
+        if ($this->legacyManager === null) {
+            // Legacy-Manager einbinden
+            $legacyFile = dirname(__DIR__, 2) . '/SettingsManager.php';
+            if (file_exists($legacyFile) && !class_exists('\SettingsManager')) {
+                require_once $legacyFile;
+            }
+
+            if (class_exists('\SettingsManager')) {
+                $this->legacyManager = new \SettingsManager();
+            }
+        }
+
+        if ($this->legacyManager) {
+            // Konvertiere Legacy-Settings in unser Format
+            $this->settings = $this->convertLegacySettings($this->legacyManager);
+        } else {
+            $this->settings = $this->getDefaults();
+        }
+
+        $this->loaded = true;
+    }
+
+    /**
+     * Konvertiert Legacy-Settings
+     */
+    private function convertLegacySettings(\SettingsManager $legacy): array
+    {
+        $settings = $this->getDefaults();
+
+        // Mappe Legacy-Werte
+        $mappings = [
+            'viewer_display.enabled' => 'viewer_display.enabled',
+            'viewer_display.min_viewers' => 'viewer_display.min_viewers',
+            'video_mode.play_in_player' => 'video_mode.play_in_player',
+            'video_mode.allow_download' => 'video_mode.allow_download',
+            'timelapse.default_speed' => 'timelapse.default_speed',
+            'ui_display.show_recommendation_banner' => 'ui_display.show_recommendation_banner',
+            'ui_display.show_qr_code' => 'ui_display.show_qr_code',
+            'ui_display.show_social_media' => 'ui_display.show_social_media',
+            'content.guestbook_enabled' => 'content.guestbook_enabled',
+            'content.gallery_enabled' => 'content.gallery_enabled',
+            'weather.enabled' => 'weather.enabled',
+            'weather.location' => 'weather.location',
+            'weather.lat' => 'weather.lat',
+            'weather.lon' => 'weather.lon',
+            'seo.custom_title' => 'seo.custom_title',
+            'seo.meta_description' => 'seo.meta_description',
+        ];
+
+        foreach ($mappings as $legacyKey => $newKey) {
+            $value = $legacy->get($legacyKey);
+            if ($value !== null) {
+                $settings[$newKey] = $value;
+            }
+        }
+
+        return $settings;
+    }
+
+    /**
+     * Gibt einen Setting-Wert zurück (mit Dot-Notation)
+     */
+    public function get(string $key, mixed $default = null): mixed
+    {
+        $this->load();
+
+        // Direkte Keys
+        if (isset($this->settings[$key])) {
+            return $this->settings[$key];
+        }
+
+        // Dot-Notation auflösen
+        $keys = explode('.', $key);
+        $value = $this->settings;
+
+        foreach ($keys as $k) {
+            if (!is_array($value) || !isset($value[$k])) {
+                return $default;
+            }
+            $value = $value[$k];
+        }
+
+        return $value;
+    }
+
+    /**
+     * Setzt einen Setting-Wert
+     */
+    public function set(string $key, mixed $value): bool
+    {
+        $this->load();
+
+        // Wenn keine DB, nutze Legacy
+        if (!$this->dbAvailable || $this->tenantId === 0) {
+            return $this->setLegacy($key, $value);
+        }
+
+        // Wert für DB vorbereiten
+        $dbValue = $this->prepareValueForDb($value);
+
+        // UPSERT
+        $sql = "INSERT INTO tenant_settings (tenant_id, setting_key, setting_value)
+                VALUES (?, ?, ?)
+                ON DUPLICATE KEY UPDATE setting_value = VALUES(setting_value)";
+
+        $result = $this->db->execute($sql, [$this->tenantId, $key, $dbValue]) > 0;
+
+        if ($result) {
+            $this->settings[$key] = $value;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Setzt Legacy-Setting
+     */
+    private function setLegacy(string $key, mixed $value): bool
+    {
+        if ($this->legacyManager) {
+            return $this->legacyManager->set($key, $value);
+        }
+        return false;
+    }
+
+    /**
+     * Bereitet einen Wert für die DB vor
+     */
+    private function prepareValueForDb(mixed $value): string
+    {
+        if (is_bool($value)) {
+            return $value ? 'true' : 'false';
+        }
+        if (is_array($value) || is_object($value)) {
+            return json_encode($value);
+        }
+        return (string)$value;
+    }
+
+    /**
+     * Löscht ein Setting
+     */
+    public function delete(string $key): bool
+    {
+        if (!$this->dbAvailable || $this->tenantId === 0) {
+            return false;
+        }
+
+        $result = $this->db->delete('tenant_settings', 'tenant_id = ? AND setting_key = ?', [$this->tenantId, $key]) > 0;
+
+        if ($result) {
+            unset($this->settings[$key]);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Gibt alle Settings zurück
+     */
+    public function all(): array
+    {
+        $this->load();
+        return $this->settings;
+    }
+
+    /**
+     * Setzt mehrere Settings auf einmal
+     */
+    public function setMany(array $settings): bool
+    {
+        foreach ($settings as $key => $value) {
+            $this->set($key, $value);
+        }
+        return true;
+    }
+
+    /**
+     * Default-Settings
+     */
+    private function getDefaults(): array
+    {
+        return [
+            // Viewer Display
+            'viewer_display.enabled' => true,
+            'viewer_display.min_viewers' => 1,
+            'viewer_display.update_interval' => 5,
+
+            // Video Mode
+            'video_mode.play_in_player' => true,
+            'video_mode.allow_download' => true,
+
+            // Timelapse
+            'timelapse.default_speed' => 1,
+            'timelapse.available_speeds' => [1, 10, 100],
+            'timelapse.reverse_enabled' => true,
+
+            // UI Display
+            'ui_display.show_recommendation_banner' => true,
+            'ui_display.show_qr_code' => true,
+            'ui_display.show_social_media' => true,
+
+            // Zoom
+            'zoom.show_controls' => true,
+            'zoom.max_level' => 4.0,
+
+            // Content
+            'content.guestbook_enabled' => true,
+            'content.gallery_enabled' => true,
+            'content.ai_events_enabled' => true,
+
+            // Weather
+            'weather.enabled' => true,
+            'weather.location' => 'Zürich,CH',
+            'weather.lat' => '47.3769',
+            'weather.lon' => '8.5417',
+            'weather.update_interval' => 5,
+            'weather.units' => 'metric',
+
+            // SEO
+            'seo.custom_title' => '',
+            'seo.meta_description' => '',
+            'seo.meta_keywords' => '',
+
+            // Theme
+            'theme.default' => 'theme-legacy',
+            'theme.show_switcher' => false,
+        ];
+    }
+
+    // === Helper-Methoden (kompatibel mit altem SettingsManager) ===
+
+    public function isWeatherEnabled(): bool
+    {
+        return $this->get('weather.enabled', true) === true;
+    }
+
+    public function getWeatherLocation(): string
+    {
+        return $this->get('weather.location', 'Zürich,CH');
+    }
+
+    public function getWeatherCoords(): array
+    {
+        return [
+            'lat' => $this->get('weather.lat', '47.3769'),
+            'lon' => $this->get('weather.lon', '8.5417'),
+        ];
+    }
+
+    public function getWeatherUpdateInterval(): int
+    {
+        return (int)$this->get('weather.update_interval', 5);
+    }
+
+    public function shouldShowViewers(): bool
+    {
+        return $this->get('viewer_display.enabled', true) === true;
+    }
+
+    public function getMinViewers(): int
+    {
+        return (int)$this->get('viewer_display.min_viewers', 1);
+    }
+
+    public function isGuestbookEnabled(): bool
+    {
+        return $this->get('content.guestbook_enabled', true) === true;
+    }
+
+    public function isGalleryEnabled(): bool
+    {
+        return $this->get('content.gallery_enabled', true) === true;
+    }
+
+    /**
+     * AJAX-Handler (kompatibel mit altem SettingsManager)
+     */
+    public function handleAjax(): void
+    {
+        if ($_SERVER['REQUEST_METHOD'] !== 'POST') return;
+        if (!isset($_POST['settings_action'])) return;
+
+        header('Content-Type: application/json');
+
+        // Auth prüfen
+        if (!$this->isAdmin()) {
+            echo json_encode(['success' => false, 'error' => 'Unauthorized']);
+            exit;
+        }
+
+        $action = $_POST['settings_action'];
+
+        if ($action === 'update' && isset($_POST['key'], $_POST['value'])) {
+            $key = $_POST['key'];
+            $value = $_POST['value'];
+
+            // Booleans konvertieren
+            if ($value === 'true') $value = true;
+            elseif ($value === 'false') $value = false;
+
+            $success = $this->set($key, $value);
+            echo json_encode(['success' => $success]);
+            exit;
+        }
+
+        if ($action === 'get') {
+            echo json_encode(['success' => true, 'data' => $this->all()]);
+            exit;
+        }
+
+        echo json_encode(['success' => false, 'error' => 'Unknown action']);
+        exit;
+    }
+
+    /**
+     * Prüft ob der User Admin ist
+     */
+    private function isAdmin(): bool
+    {
+        return isset($_SESSION['admin']) && $_SESSION['admin'] === true;
+    }
+
+    /**
+     * Lädt Settings neu aus der DB
+     */
+    public function reload(): void
+    {
+        $this->loaded = false;
+        $this->settings = [];
+        $this->load();
+    }
+}

aurora-livecam/src/bootstrap.php

@@ -0,0 +1,179 @@
+<?php
+/**
+ * Bootstrap - Initialisiert die Multi-Tenant Umgebung
+ *
+ * Einbinden am Anfang von index.php:
+ *   require_once __DIR__ . '/src/bootstrap.php';
+ */
+
+// Autoloader für src/ Klassen
+spl_autoload_register(function ($class) {
+    // Namespace-Präfix
+    $prefix = 'AuroraLivecam\\';
+    $baseDir = __DIR__ . '/';
+
+    // Prüfe ob die Klasse unseren Namespace verwendet
+    $len = strlen($prefix);
+    if (strncmp($prefix, $class, $len) !== 0) {
+        return;
+    }
+
+    // Relativer Klassenname
+    $relativeClass = substr($class, $len);
+
+    // Pfad zur Datei
+    $file = $baseDir . str_replace('\\', '/', $relativeClass) . '.php';
+
+    if (file_exists($file)) {
+        require $file;
+    }
+});
+
+use AuroraLivecam\Core\TenantResolver;
+use AuroraLivecam\Core\Database;
+
+/**
+ * Gibt die Site-Konfiguration basierend auf dem aktuellen Tenant zurück
+ * Ersetzt den hardcoded Domain-Switch in index.php
+ */
+function getSiteConfig(): array
+{
+    // Legacy SettingsManager laden
+    $settingsFile = dirname(__DIR__) . '/SettingsManager.php';
+    if (!class_exists('SettingsManager') && file_exists($settingsFile)) {
+        require_once $settingsFile;
+    }
+
+    $settingsManager = new \SettingsManager();
+
+    // Wenn Multi-Tenant nicht aktiviert, nutze Legacy-Modus
+    if (!$settingsManager->isMultiTenantEnabled()) {
+        return getLegacySiteConfig();
+    }
+
+    // Multi-Tenant Modus
+    try {
+        $resolver = TenantResolver::getInstance();
+        $tenant = $resolver->resolve();
+        $branding = $resolver->getBranding();
+
+        if (!$tenant) {
+            return getLegacySiteConfig();
+        }
+
+        return [
+            'tenant_id' => $tenant['id'],
+            'tenant_slug' => $tenant['slug'],
+            'is_multi_tenant' => true,
+            'site_name' => $branding['site_name'] ?? $tenant['name'],
+            'site_name_full' => $branding['site_name_full'] ?? $tenant['name'],
+            'tagline' => $branding['tagline'] ?? '',
+            'logo_path' => $branding['logo_path'] ?? null,
+            'favicon_path' => $branding['favicon_path'] ?? null,
+            'primary_color' => $branding['primary_color'] ?? '#667eea',
+            'secondary_color' => $branding['secondary_color'] ?? '#764ba2',
+            'accent_color' => $branding['accent_color'] ?? '#f093fb',
+            'welcome_de' => $branding['welcome_text_de'] ?? '',
+            'welcome_en' => $branding['welcome_text_en'] ?? '',
+            'footer_text' => $branding['footer_text'] ?? '',
+            'custom_css' => $branding['custom_css'] ?? '',
+            'social' => [
+                'facebook' => $branding['social_facebook'] ?? '',
+                'instagram' => $branding['social_instagram'] ?? '',
+                'youtube' => $branding['social_youtube'] ?? '',
+            ],
+        ];
+
+    } catch (\Exception $e) {
+        // Fallback auf Legacy bei Fehlern
+        return getLegacySiteConfig();
+    }
+}
+
+/**
+ * Legacy Site-Konfiguration (hardcoded Domains)
+ * Kompatibilität mit bestehendem Code
+ */
+function getLegacySiteConfig(): array
+{
+    $host = $_SERVER['HTTP_HOST'] ?? 'localhost';
+    $isSeecam = (stripos($host, 'seecam.ch') !== false);
+
+    if ($isSeecam) {
+        return [
+            'tenant_id' => 0,
+            'tenant_slug' => 'seecam',
+            'is_multi_tenant' => false,
+            'site_name' => 'Seecam',
+            'site_name_full' => 'Seecam.ch - Live Webcam am See',
+            'tagline' => 'Ihre Live-Webcam am See',
+            'logo_path' => null,
+            'favicon_path' => null,
+            'primary_color' => '#667eea',
+            'secondary_color' => '#764ba2',
+            'accent_color' => '#f093fb',
+            'welcome_de' => 'Willkommen bei Seecam - Ihrer Live-Webcam am See!',
+            'welcome_en' => 'Welcome to Seecam - Your Live Webcam at the Lake!',
+            'footer_text' => '',
+            'custom_css' => '',
+            'social' => [
+                'facebook' => '',
+                'instagram' => '',
+                'youtube' => '',
+            ],
+        ];
+    }
+
+    // Default: Aurora
+    return [
+        'tenant_id' => 0,
+        'tenant_slug' => 'aurora',
+        'is_multi_tenant' => false,
+        'site_name' => 'Aurora',
+        'site_name_full' => 'Aurora Weather Livecam - Zürich Oberland',
+        'tagline' => 'Wetter Webcam Schweiz - Zürich Oberland',
+        'logo_path' => null,
+        'favicon_path' => null,
+        'primary_color' => '#667eea',
+        'secondary_color' => '#764ba2',
+        'accent_color' => '#f093fb',
+        'welcome_de' => 'Willkommen bei Aurora Weather Livecam - Ihre Wetter-Webcam im Zürcher Oberland mit AI-Erkennung für Aurora, Starlink und mehr!',
+        'welcome_en' => 'Welcome to Aurora Weather Livecam - Your weather webcam in the Zurich Oberland with AI detection for Aurora, Starlink and more!',
+        'footer_text' => '',
+        'custom_css' => '',
+        'social' => [
+            'facebook' => '',
+            'instagram' => '',
+            'youtube' => '',
+        ],
+    ];
+}
+
+/**
+ * Redirect Handler für alte Domains
+ */
+function handleDomainRedirects(): void
+{
+    $host = $_SERVER['HTTP_HOST'] ?? '';
+
+    // Alte Aurora-Domains auf neue Domain umleiten
+    $oldDomains = [
+        'www.aurora-wetter-lifecam.ch',
+        'aurora-wetter-lifecam.ch',
+        'www.aurora-wetter-livecam.ch',
+        'aurora-wetter-livecam.ch'
+    ];
+
+    $newDomain = 'www.aurora-weather-livecam.com';
+
+    if (in_array($host, $oldDomains)) {
+        $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
+        $requestUri = $_SERVER['REQUEST_URI'] ?? '/';
+        header("HTTP/1.1 301 Moved Permanently");
+        header("Location: {$protocol}://{$newDomain}{$requestUri}");
+        exit;
+    }
+}
+
+// Domain-Redirects automatisch ausführen
+handleDomainRedirects();

aurora-livecam/test-weather.php

@@ -0,0 +1,31 @@
+<?php
+// Fehler anzeigen
+error_reporting(E_ALL);
+ini_set('display_errors', 1);
+
+echo "Test 1: Settings Manager laden...<br>";
+require_once 'SettingsManager.php';
+echo "✓ SettingsManager.php geladen<br>";
+
+echo "Test 2: Weather Manager laden...<br>";
+require_once 'WeatherManager.php';
+echo "✓ WeatherManager.php geladen<br>";
+
+echo "Test 3: SettingsManager initialisieren...<br>";
+$settingsManager = new SettingsManager();
+echo "✓ SettingsManager initialisiert<br>";
+
+echo "Test 4: WeatherManager initialisieren...<br>";
+$weatherManager = new WeatherManager($settingsManager);
+echo "✓ WeatherManager initialisiert<br>";
+
+echo "Test 5: Wetter abrufen...<br>";
+$weather = $weatherManager->getCurrentWeather();
+echo "✓ Wetter abgerufen<br>";
+
+echo "<pre>";
+print_r($weather);
+echo "</pre>";
+
+echo "<br><br>✅ ALLE TESTS ERFOLGREICH!";
+?>

dctp/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.pyo
+.dctp_backups/
+.dctp_settings.json

dctp/CLAUDE.md

@@ -0,0 +1,102 @@
+# DCTP - Delta Code Transfer Protocol
+
+Du generierst Code im DCTP-Format fuer effiziente Uebertragung.
+
+## Regeln
+
+1. **Zeilennummern am Ende jeder Zeile** im passenden Kommentar-Format
+2. **Immer mit ###FILE: beginnen** bei jedem Codeblock
+3. **Bei Korrekturen NUR die geaenderten Zeilen senden**, nie den ganzen File
+
+## Zeilennummern-Format
+
+- Python/Shell: `code  #Z1`
+- JavaScript/Java/C/C++: `code  //Z1`
+- HTML: `code  <!--Z1-->`
+- CSS: `code  /*Z1*/`
+- SQL: `code  --Z1`
+
+## Befehle
+
+| Befehl | Syntax | Beschreibung |
+|--------|--------|--------------|
+| `###FILE:` | `###FILE:pfad/datei.ext` | Datei angeben |
+| `###NEW` | | Neue Datei, kompletter Inhalt folgt |
+| `###DELETE:` | `###DELETE:Z5-Z12` | Zeilen 5-12 loeschen |
+| `###INSERT_AFTER:` | `###INSERT_AFTER:Z5` | Nach Zeile 5 einfuegen |
+| `###REPLACE:` | `###REPLACE:Z5-Z8` | Zeilen 5-8 ersetzen |
+| `###END` | | Ende des Blocks |
+| `###RENUMBER` | | Zeilennummern neu berechnen |
+| `###CHECKSUM:` | `###CHECKSUM:a3f2b8c1` | Optional: Hash zur Validierung |
+
+## Beispiel: Neue Datei
+
+```
+###FILE:src/calculator.py
+###NEW
+def add(a, b):  #Z1
+    return a + b  #Z2
+  #Z3
+def multiply(a, b):  #Z4
+    return a * b  #Z5
+###END
+```
+
+## Beispiel: Korrektur (REPLACE)
+
+```
+###FILE:src/calculator.py
+###REPLACE:Z4-Z5
+def multiply(a, b):  #Z4
+    """Multipliziert zwei Zahlen."""  #Z5
+    return a * b  #Z6
+###END
+###RENUMBER
+```
+
+## Beispiel: Zeilen einfuegen
+
+```
+###FILE:src/calculator.py
+###INSERT_AFTER:Z2
+  #Z3
+def subtract(a, b):  #Z4
+    return a - b  #Z5
+###END
+###RENUMBER
+```
+
+## Beispiel: Zeilen loeschen
+
+```
+###FILE:src/calculator.py
+###DELETE:Z10-Z15
+###RENUMBER
+```
+
+## Beispiel: Mehrere Dateien
+
+```
+###FILE:src/models/user.py
+###NEW
+class User:  #Z1
+    def __init__(self, name: str):  #Z2
+        self.name = name  #Z3
+###END
+
+###FILE:src/models/order.py
+###NEW
+from .user import User  #Z1
+  #Z2
+class Order:  #Z3
+    def __init__(self, user: User):  #Z4
+        self.user = user  #Z5
+###END
+```
+
+## Wichtig
+
+- Bei Korrekturen: NUR Delta senden, nie kompletten File
+- Nach INSERT/DELETE/REPLACE immer ###RENUMBER
+- Leerzeilen auch nummerieren
+- Zeilennummern werden beim Schreiben automatisch entfernt

dctp/README.md

@@ -0,0 +1,147 @@
+# DCTP - Delta Code Transfer Protocol
+
+Ein Tool um KI-generierten Code effizient in lokale Dateien zu uebertragen. Statt bei jeder Korrektur den kompletten Code neu zu senden, werden nur Aenderungen (Deltas) uebertragen.
+
+## Das Problem
+
+Claude generiert 500 Zeilen Code. Eine kleine Korrektur = nochmal 500 Zeilen. Verschwendung.
+
+## Die Loesung
+
+Zeilennummerierter Code + Steueranweisungen fuer gezielte Aenderungen.
+
+## Installation
+
+```bash
+# Requirements installieren
+pip install -r requirements.txt
+
+# GUI starten
+python dctp_gui.py
+```
+
+## Schnellstart
+
+### 1. Projektverzeichnis waehlen
+
+Klicke auf "Waehlen" und waehle dein Projektverzeichnis.
+
+### 2. KI-Output einfuegen
+
+Kopiere den DCTP-formatierten Output aus deinem Claude-Chat in das Input-Feld.
+
+### 3. Analysieren
+
+Klicke "Analysieren" um eine Vorschau der Operationen zu sehen.
+
+### 4. Ausfuehren
+
+Klicke "Ausfuehren" um die Aenderungen auf deine Dateien anzuwenden.
+
+## DCTP-Format
+
+### Neue Datei erstellen
+
+```
+###FILE:src/calculator.py
+###NEW
+def add(a, b):  #Z1
+    return a + b  #Z2
+###END
+```
+
+### Zeilen ersetzen
+
+```
+###FILE:src/calculator.py
+###REPLACE:Z1-Z2
+def add(a: int, b: int) -> int:  #Z1
+    """Addiert zwei Zahlen."""  #Z2
+    return a + b  #Z3
+###END
+###RENUMBER
+```
+
+### Zeilen einfuegen
+
+```
+###FILE:src/calculator.py
+###INSERT_AFTER:Z2
+  #Z3
+def subtract(a, b):  #Z4
+    return a - b  #Z5
+###END
+###RENUMBER
+```
+
+### Zeilen loeschen
+
+```
+###FILE:src/calculator.py
+###DELETE:Z10-Z15
+###RENUMBER
+```
+
+## Zeilennummern-Format
+
+Die Zeilennummern werden automatisch entsprechend der Programmiersprache formatiert:
+
+| Sprache | Format | Beispiel |
+|---------|--------|----------|
+| Python | `#Z1` | `code  #Z1` |
+| JavaScript | `//Z1` | `code  //Z1` |
+| HTML | `<!--Z1-->` | `code  <!--Z1-->` |
+| CSS | `/*Z1*/` | `code  /*Z1*/` |
+| SQL | `--Z1` | `code  --Z1` |
+
+## Befehle
+
+| Befehl | Beschreibung |
+|--------|--------------|
+| `###FILE:pfad` | Zieldatei angeben |
+| `###NEW` | Neue Datei erstellen |
+| `###DELETE:Z5-Z12` | Zeilen loeschen |
+| `###INSERT_AFTER:Z5` | Nach Zeile einfuegen |
+| `###REPLACE:Z5-Z8` | Zeilen ersetzen |
+| `###END` | Block beenden |
+| `###RENUMBER` | Zeilennummern aktualisieren |
+| `###CHECKSUM:hash` | Datei-Hash validieren |
+
+## Features
+
+- **Vorschau**: Zeigt was passieren wird, bevor es ausgefuehrt wird
+- **Diff-Ansicht**: Zeigt Aenderungen farbig markiert (alt vs neu)
+- **Undo**: Stellt den letzten Zustand wieder her
+- **Backup**: Automatische Backups vor jeder Aenderung
+- **Multi-File**: Mehrere Dateien in einem Durchgang bearbeiten
+- **Checksum**: Optionale Validierung gegen externe Aenderungen
+
+## Einstellungen
+
+- **Projektpfad**: Standard-Projektverzeichnis
+- **Backup-Verzeichnis**: Wo Backups gespeichert werden
+- **Auto-Renumber**: Zeilennummern automatisch aktualisieren
+- **Checksum-Validierung**: Externe Aenderungen erkennen
+- **Theme**: Hell oder dunkel
+
+## Claude-Integration
+
+Kopiere den Inhalt von `CLAUDE.md` in deine Claude-Chats (als Custom Instructions oder am Anfang des Gespraechs), damit Claude im DCTP-Format antwortet.
+
+## Architektur
+
+```
+dctp/
+├── dctp_gui.py          # Hauptfenster (CustomTkinter)
+├── dctp_parser.py       # Core-Logik: parse Steueranweisungen
+├── dctp_executor.py     # Fuehrt Operationen aus
+├── dctp_backup.py       # Undo/Backup-Verwaltung
+├── dctp_diff.py         # Diff-Berechnung fuer Vorschau
+├── requirements.txt     # Dependencies
+├── CLAUDE.md            # Anweisung fuer KI
+└── README.md            # Diese Datei
+```
+
+## Lizenz
+
+MIT License

dctp/dctp_backup.py

@@ -0,0 +1,305 @@
+"""
+DCTP Backup Manager - Handles backup and undo functionality.
+
+Creates timestamped backups before operations and supports
+restoring files to their previous state.
+"""
+
+import json
+import os
+import shutil
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class FileBackup:
+    """Represents a single file backup."""
+    original: str
+    backup: str
+    existed: bool  # Whether the file existed before (for new file handling)
+
+
+@dataclass
+class BackupSession:
+    """Represents a backup session (one execution run)."""
+    timestamp: str
+    files: list[FileBackup]
+
+
+@dataclass
+class BackupInfo:
+    """Info about a backup for display purposes."""
+    timestamp: str
+    file_count: int
+    files: list[str]
+
+
+class BackupManager:
+    """Manages file backups for undo functionality."""
+
+    BACKUP_DIR_NAME = ".dctp_backups"
+    MANIFEST_FILE = "manifest.json"
+    MAX_SESSIONS = 50  # Keep last 50 sessions
+
+    def __init__(self, project_path: str):
+        """
+        Initialize backup manager.
+
+        Args:
+            project_path: Base project directory
+        """
+        self.project_path = Path(project_path)
+        self.backup_dir = self.project_path / self.BACKUP_DIR_NAME
+        self.manifest_path = self.backup_dir / self.MANIFEST_FILE
+        self._current_session: Optional[BackupSession] = None
+        self._ensure_backup_dir()
+
+    def _ensure_backup_dir(self) -> None:
+        """Create backup directory if it doesn't exist."""
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create .gitignore in backup dir
+        gitignore_path = self.backup_dir / ".gitignore"
+        if not gitignore_path.exists():
+            gitignore_path.write_text("*\n")
+
+    def _load_manifest(self) -> dict:
+        """Load the manifest file."""
+        if self.manifest_path.exists():
+            try:
+                return json.loads(self.manifest_path.read_text())
+            except (json.JSONDecodeError, IOError):
+                return {"sessions": []}
+        return {"sessions": []}
+
+    def _save_manifest(self, manifest: dict) -> None:
+        """Save the manifest file."""
+        self.manifest_path.write_text(json.dumps(manifest, indent=2))
+
+    def start_session(self) -> None:
+        """Start a new backup session."""
+        timestamp = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+        self._current_session = BackupSession(timestamp=timestamp, files=[])
+
+    def backup(self, file_path: str) -> Optional[str]:
+        """
+        Create a backup of a file.
+
+        Args:
+            file_path: Path to the file (relative to project or absolute)
+
+        Returns:
+            Backup filename if successful, None if file doesn't exist
+        """
+        if self._current_session is None:
+            self.start_session()
+
+        # Normalize path
+        if os.path.isabs(file_path):
+            full_path = Path(file_path)
+            rel_path = full_path.relative_to(self.project_path)
+        else:
+            rel_path = Path(file_path)
+            full_path = self.project_path / rel_path
+
+        # Check if file exists
+        existed = full_path.exists()
+
+        if existed:
+            # Generate backup filename
+            timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
+            safe_name = str(rel_path).replace(os.sep, "_").replace("/", "_")
+            backup_name = f"{timestamp}_{safe_name}"
+
+            # Copy file to backup
+            backup_path = self.backup_dir / backup_name
+            shutil.copy2(full_path, backup_path)
+        else:
+            backup_name = ""
+
+        # Add to current session
+        self._current_session.files.append(FileBackup(
+            original=str(rel_path),
+            backup=backup_name,
+            existed=existed
+        ))
+
+        return backup_name if existed else None
+
+    def end_session(self) -> None:
+        """End the current backup session and save to manifest."""
+        if self._current_session is None or len(self._current_session.files) == 0:
+            self._current_session = None
+            return
+
+        manifest = self._load_manifest()
+
+        # Convert to dict for JSON storage
+        session_dict = {
+            "timestamp": self._current_session.timestamp,
+            "files": [asdict(f) for f in self._current_session.files]
+        }
+        manifest["sessions"].append(session_dict)
+
+        # Limit number of sessions
+        if len(manifest["sessions"]) > self.MAX_SESSIONS:
+            # Remove old sessions and their backup files
+            old_sessions = manifest["sessions"][:-self.MAX_SESSIONS]
+            for session in old_sessions:
+                for file_info in session["files"]:
+                    backup_file = self.backup_dir / file_info["backup"]
+                    if backup_file.exists():
+                        backup_file.unlink()
+            manifest["sessions"] = manifest["sessions"][-self.MAX_SESSIONS:]
+
+        self._save_manifest(manifest)
+        self._current_session = None
+
+    def restore_last(self) -> tuple[bool, list[str]]:
+        """
+        Restore files from the last backup session.
+
+        Returns:
+            Tuple of (success, list of restored files)
+        """
+        manifest = self._load_manifest()
+
+        if not manifest["sessions"]:
+            return False, []
+
+        # Get last session
+        last_session = manifest["sessions"].pop()
+        restored_files = []
+
+        for file_info in last_session["files"]:
+            original_path = self.project_path / file_info["original"]
+
+            if file_info["existed"]:
+                # Restore from backup
+                backup_path = self.backup_dir / file_info["backup"]
+                if backup_path.exists():
+                    # Ensure parent directory exists
+                    original_path.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(backup_path, original_path)
+                    backup_path.unlink()  # Remove backup file
+                    restored_files.append(file_info["original"])
+            else:
+                # File was newly created, delete it
+                if original_path.exists():
+                    original_path.unlink()
+                    restored_files.append(f"{file_info['original']} (deleted)")
+
+        self._save_manifest(manifest)
+        return True, restored_files
+
+    def list_backups(self) -> list[BackupInfo]:
+        """
+        List all backup sessions.
+
+        Returns:
+            List of BackupInfo objects, newest first
+        """
+        manifest = self._load_manifest()
+        backups = []
+
+        for session in reversed(manifest["sessions"]):
+            files = [f["original"] for f in session["files"]]
+            backups.append(BackupInfo(
+                timestamp=session["timestamp"],
+                file_count=len(files),
+                files=files
+            ))
+
+        return backups
+
+    def get_file_backup_path(self, file_path: str) -> Optional[Path]:
+        """
+        Get the backup path for a file from the most recent session.
+
+        Args:
+            file_path: Original file path (relative to project)
+
+        Returns:
+            Path to backup file if found, None otherwise
+        """
+        manifest = self._load_manifest()
+
+        if not manifest["sessions"]:
+            return None
+
+        # Search from newest to oldest
+        for session in reversed(manifest["sessions"]):
+            for file_info in session["files"]:
+                if file_info["original"] == file_path and file_info["existed"]:
+                    backup_path = self.backup_dir / file_info["backup"]
+                    if backup_path.exists():
+                        return backup_path
+
+        return None
+
+    def clear_all_backups(self) -> int:
+        """
+        Clear all backups.
+
+        Returns:
+            Number of backup files deleted
+        """
+        count = 0
+        if self.backup_dir.exists():
+            for item in self.backup_dir.iterdir():
+                if item.name != ".gitignore":
+                    if item.is_file():
+                        item.unlink()
+                        count += 1
+                    elif item.is_dir():
+                        shutil.rmtree(item)
+                        count += 1
+
+        # Reset manifest
+        self._save_manifest({"sessions": []})
+        return count
+
+
+def main():
+    """Test the backup manager."""
+    import tempfile
+
+    # Create a temporary project directory
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create some test files
+        test_file = Path(tmpdir) / "test.py"
+        test_file.write_text("print('hello')\n")
+
+        # Initialize backup manager
+        manager = BackupManager(tmpdir)
+
+        # Start a session and backup the file
+        manager.start_session()
+        backup_name = manager.backup("test.py")
+        print(f"Created backup: {backup_name}")
+
+        # Modify the file
+        test_file.write_text("print('modified')\n")
+        print(f"File content after modification: {test_file.read_text()}")
+
+        # End session
+        manager.end_session()
+
+        # List backups
+        backups = manager.list_backups()
+        print(f"Backup sessions: {len(backups)}")
+        for b in backups:
+            print(f"  {b.timestamp}: {b.file_count} files")
+
+        # Restore
+        success, restored = manager.restore_last()
+        print(f"Restore successful: {success}")
+        print(f"Restored files: {restored}")
+        print(f"File content after restore: {test_file.read_text()}")
+
+
+if __name__ == "__main__":
+    main()

dctp/dctp_diff.py

@@ -0,0 +1,385 @@
+"""
+DCTP Diff Generator - Generates diffs for preview display.
+
+Compares old and new content and produces colored diff output
+for the GUI preview.
+"""
+
+import difflib
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class DiffType(Enum):
+    UNCHANGED = "unchanged"
+    ADDED = "added"
+    REMOVED = "removed"
+    CONTEXT = "context"
+
+
+@dataclass
+class DiffLine:
+    """Represents a single line in a diff."""
+    type: DiffType
+    line_number_old: Optional[int]  # Line number in old file
+    line_number_new: Optional[int]  # Line number in new file
+    content: str
+
+    @property
+    def prefix(self) -> str:
+        """Get the diff prefix character."""
+        if self.type == DiffType.ADDED:
+            return "+"
+        elif self.type == DiffType.REMOVED:
+            return "-"
+        else:
+            return " "
+
+    def __str__(self) -> str:
+        old_num = str(self.line_number_old) if self.line_number_old else ""
+        new_num = str(self.line_number_new) if self.line_number_new else ""
+        return f"{old_num:>4} {new_num:>4} {self.prefix} {self.content}"
+
+
+@dataclass
+class DiffBlock:
+    """A block of related diff lines."""
+    start_old: int
+    end_old: int
+    start_new: int
+    end_new: int
+    lines: list[DiffLine]
+
+    @property
+    def header(self) -> str:
+        """Generate a unified diff style header."""
+        return f"@@ -{self.start_old},{self.end_old - self.start_old + 1} +{self.start_new},{self.end_new - self.start_new + 1} @@"
+
+
+@dataclass
+class FileDiff:
+    """Complete diff for a file."""
+    filename: str
+    old_content: list[str]
+    new_content: list[str]
+    blocks: list[DiffBlock]
+    lines: list[DiffLine]
+
+    @property
+    def has_changes(self) -> bool:
+        return any(line.type in (DiffType.ADDED, DiffType.REMOVED) for line in self.lines)
+
+    @property
+    def additions(self) -> int:
+        return sum(1 for line in self.lines if line.type == DiffType.ADDED)
+
+    @property
+    def deletions(self) -> int:
+        return sum(1 for line in self.lines if line.type == DiffType.REMOVED)
+
+
+class DiffGenerator:
+    """Generates diffs between old and new content."""
+
+    def __init__(self, context_lines: int = 3):
+        """
+        Initialize diff generator.
+
+        Args:
+            context_lines: Number of context lines around changes
+        """
+        self.context_lines = context_lines
+
+    def generate(
+        self,
+        old_lines: list[str],
+        new_lines: list[str],
+        filename: str = ""
+    ) -> FileDiff:
+        """
+        Generate a diff between old and new content.
+
+        Args:
+            old_lines: Original content lines
+            new_lines: New content lines
+            filename: Optional filename for display
+
+        Returns:
+            FileDiff object with all diff information
+        """
+        diff_lines: list[DiffLine] = []
+
+        # Use difflib to compute differences
+        matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
+
+        old_line_num = 1
+        new_line_num = 1
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == 'equal':
+                for idx in range(i2 - i1):
+                    diff_lines.append(DiffLine(
+                        type=DiffType.UNCHANGED,
+                        line_number_old=old_line_num,
+                        line_number_new=new_line_num,
+                        content=old_lines[i1 + idx]
+                    ))
+                    old_line_num += 1
+                    new_line_num += 1
+
+            elif tag == 'replace':
+                # Show removed lines first, then added
+                for idx in range(i2 - i1):
+                    diff_lines.append(DiffLine(
+                        type=DiffType.REMOVED,
+                        line_number_old=old_line_num,
+                        line_number_new=None,
+                        content=old_lines[i1 + idx]
+                    ))
+                    old_line_num += 1
+
+                for idx in range(j2 - j1):
+                    diff_lines.append(DiffLine(
+                        type=DiffType.ADDED,
+                        line_number_old=None,
+                        line_number_new=new_line_num,
+                        content=new_lines[j1 + idx]
+                    ))
+                    new_line_num += 1
+
+            elif tag == 'delete':
+                for idx in range(i2 - i1):
+                    diff_lines.append(DiffLine(
+                        type=DiffType.REMOVED,
+                        line_number_old=old_line_num,
+                        line_number_new=None,
+                        content=old_lines[i1 + idx]
+                    ))
+                    old_line_num += 1
+
+            elif tag == 'insert':
+                for idx in range(j2 - j1):
+                    diff_lines.append(DiffLine(
+                        type=DiffType.ADDED,
+                        line_number_old=None,
+                        line_number_new=new_line_num,
+                        content=new_lines[j1 + idx]
+                    ))
+                    new_line_num += 1
+
+        # Generate blocks with context
+        blocks = self._generate_blocks(diff_lines)
+
+        return FileDiff(
+            filename=filename,
+            old_content=old_lines,
+            new_content=new_lines,
+            blocks=blocks,
+            lines=diff_lines
+        )
+
+    def _generate_blocks(self, diff_lines: list[DiffLine]) -> list[DiffBlock]:
+        """Generate diff blocks with context."""
+        if not diff_lines:
+            return []
+
+        blocks: list[DiffBlock] = []
+        current_block_lines: list[DiffLine] = []
+        in_change = False
+        unchanged_count = 0
+
+        for line in diff_lines:
+            is_change = line.type in (DiffType.ADDED, DiffType.REMOVED)
+
+            if is_change:
+                if not in_change:
+                    # Starting a new change block, include context
+                    in_change = True
+                    unchanged_count = 0
+                current_block_lines.append(line)
+
+            else:  # Unchanged line
+                if in_change:
+                    unchanged_count += 1
+                    if unchanged_count <= self.context_lines:
+                        current_block_lines.append(line)
+                    else:
+                        # End current block and start fresh
+                        if current_block_lines:
+                            blocks.append(self._create_block(current_block_lines))
+                        current_block_lines = []
+                        in_change = False
+                        unchanged_count = 0
+                else:
+                    # Keep track of potential context lines
+                    current_block_lines.append(line)
+                    if len(current_block_lines) > self.context_lines:
+                        current_block_lines.pop(0)
+
+        # Don't forget the last block
+        if current_block_lines and any(
+            l.type in (DiffType.ADDED, DiffType.REMOVED) for l in current_block_lines
+        ):
+            blocks.append(self._create_block(current_block_lines))
+
+        return blocks
+
+    def _create_block(self, lines: list[DiffLine]) -> DiffBlock:
+        """Create a DiffBlock from a list of lines."""
+        old_nums = [l.line_number_old for l in lines if l.line_number_old is not None]
+        new_nums = [l.line_number_new for l in lines if l.line_number_new is not None]
+
+        return DiffBlock(
+            start_old=min(old_nums) if old_nums else 0,
+            end_old=max(old_nums) if old_nums else 0,
+            start_new=min(new_nums) if new_nums else 0,
+            end_new=max(new_nums) if new_nums else 0,
+            lines=lines
+        )
+
+    def generate_unified_diff(
+        self,
+        old_lines: list[str],
+        new_lines: list[str],
+        old_filename: str = "a/file",
+        new_filename: str = "b/file"
+    ) -> str:
+        """
+        Generate a unified diff string.
+
+        Args:
+            old_lines: Original content lines
+            new_lines: New content lines
+            old_filename: Label for old file
+            new_filename: Label for new file
+
+        Returns:
+            Unified diff as string
+        """
+        diff = difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile=old_filename,
+            tofile=new_filename,
+            lineterm=""
+        )
+        return "\n".join(diff)
+
+    def generate_side_by_side(
+        self,
+        old_lines: list[str],
+        new_lines: list[str],
+        width: int = 80
+    ) -> list[tuple[str, str, str]]:
+        """
+        Generate a side-by-side diff representation.
+
+        Args:
+            old_lines: Original content lines
+            new_lines: New content lines
+            width: Width for each column
+
+        Returns:
+            List of tuples (left_line, marker, right_line)
+        """
+        result = []
+        half_width = (width - 3) // 2
+
+        matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == 'equal':
+                for idx in range(i2 - i1):
+                    line = old_lines[i1 + idx][:half_width]
+                    result.append((line, " ", line))
+
+            elif tag == 'replace':
+                max_len = max(i2 - i1, j2 - j1)
+                for idx in range(max_len):
+                    old_line = old_lines[i1 + idx][:half_width] if idx < i2 - i1 else ""
+                    new_line = new_lines[j1 + idx][:half_width] if idx < j2 - j1 else ""
+                    result.append((old_line, "|", new_line))
+
+            elif tag == 'delete':
+                for idx in range(i2 - i1):
+                    old_line = old_lines[i1 + idx][:half_width]
+                    result.append((old_line, "<", ""))
+
+            elif tag == 'insert':
+                for idx in range(j2 - j1):
+                    new_line = new_lines[j1 + idx][:half_width]
+                    result.append(("", ">", new_line))
+
+        return result
+
+
+def format_diff_for_display(diff: FileDiff, use_colors: bool = True) -> str:
+    """
+    Format a FileDiff for terminal/GUI display.
+
+    Args:
+        diff: The FileDiff to format
+        use_colors: Whether to use ANSI colors
+
+    Returns:
+        Formatted string
+    """
+    lines = []
+
+    if diff.filename:
+        lines.append(f"--- {diff.filename}")
+        lines.append(f"+++ {diff.filename}")
+
+    for line in diff.lines:
+        if use_colors:
+            if line.type == DiffType.ADDED:
+                prefix = "\033[32m+"  # Green
+                suffix = "\033[0m"
+            elif line.type == DiffType.REMOVED:
+                prefix = "\033[31m-"  # Red
+                suffix = "\033[0m"
+            else:
+                prefix = " "
+                suffix = ""
+        else:
+            prefix = line.prefix
+            suffix = ""
+
+        lines.append(f"{prefix} {line.content}{suffix}")
+
+    return "\n".join(lines)
+
+
+def main():
+    """Test the diff generator."""
+    old_content = [
+        "def calculate_tax(amount):",
+        "    rate = 0.19",
+        "    if amount > 1000:",
+        "        rate = 0.25",
+        "    return amount * rate",
+    ]
+
+    new_content = [
+        "def calculate_tax(amount):",
+        "    rate = 0.19",
+        "    if amount > 10000:",
+        "        rate = 0.22",
+        "    elif amount > 1000:",
+        "        rate = 0.19",
+        "    return amount * rate",
+    ]
+
+    generator = DiffGenerator()
+    diff = generator.generate(old_content, new_content, "calculator.py")
+
+    print(f"File: {diff.filename}")
+    print(f"Additions: {diff.additions}, Deletions: {diff.deletions}")
+    print()
+    print("Diff output:")
+    print(format_diff_for_display(diff))
+
+
+if __name__ == "__main__":
+    main()

dctp/dctp_executor.py

@@ -0,0 +1,584 @@
+"""
+DCTP Executor - Executes DCTP operations on files.
+
+Handles CREATE, DELETE, INSERT_AFTER, REPLACE, and RENUMBER operations
+with backup support and checksum validation.
+"""
+
+import hashlib
+import os
+import re
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from dctp_parser import DCTPParser, Operation, OperationType
+from dctp_backup import BackupManager
+from dctp_diff import DiffGenerator, FileDiff
+
+
+class ResultStatus(Enum):
+    SUCCESS = "success"
+    WARNING = "warning"
+    ERROR = "error"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class ExecutionResult:
+    """Result of executing a single operation."""
+    status: ResultStatus
+    operation: Operation
+    message: str
+    diff: Optional[FileDiff] = None
+
+    def __str__(self) -> str:
+        status_symbols = {
+            ResultStatus.SUCCESS: "✅",
+            ResultStatus.WARNING: "⚠️",
+            ResultStatus.ERROR: "❌",
+            ResultStatus.SKIPPED: "⏭️",
+        }
+        return f"{status_symbols[self.status]} {self.message}"
+
+
+@dataclass
+class PreviewResult:
+    """Result of previewing operations before execution."""
+    operation: Operation
+    description: str
+    diff: Optional[FileDiff] = None
+    warnings: list[str] = None
+
+    def __post_init__(self):
+        if self.warnings is None:
+            self.warnings = []
+
+
+class DCTPExecutor:
+    """Executes DCTP operations on files."""
+
+    # Line number patterns (same as parser)
+    LINE_NUMBER_PATTERNS = [
+        re.compile(r'\s*#Z(\d+)\s*$'),
+        re.compile(r'\s*//Z(\d+)\s*$'),
+        re.compile(r'\s*<!--Z(\d+)-->\s*$'),
+        re.compile(r'\s*/\*Z(\d+)\*/\s*$'),
+        re.compile(r'\s*--Z(\d+)\s*$'),
+    ]
+
+    def __init__(
+        self,
+        project_path: str,
+        backup_manager: Optional[BackupManager] = None,
+        auto_renumber: bool = True,
+        validate_checksums: bool = True
+    ):
+        """
+        Initialize the executor.
+
+        Args:
+            project_path: Base project directory
+            backup_manager: Optional backup manager for undo support
+            auto_renumber: Automatically renumber after operations
+            validate_checksums: Validate checksums before operations
+        """
+        self.project_path = Path(project_path)
+        self.backup_manager = backup_manager or BackupManager(project_path)
+        self.auto_renumber = auto_renumber
+        self.validate_checksums = validate_checksums
+        self.diff_generator = DiffGenerator()
+        self.parser = DCTPParser()
+
+    def preview(self, operations: list[Operation]) -> list[PreviewResult]:
+        """
+        Preview operations without executing them.
+
+        Args:
+            operations: List of operations to preview
+
+        Returns:
+            List of preview results
+        """
+        previews = []
+
+        for op in operations:
+            preview = self._preview_operation(op)
+            previews.append(preview)
+
+        return previews
+
+    def _preview_operation(self, op: Operation) -> PreviewResult:
+        """Generate preview for a single operation."""
+        file_path = self.project_path / op.file
+        warnings = []
+
+        if op.type == OperationType.NEW:
+            if file_path.exists():
+                warnings.append(f"File already exists and will be overwritten")
+            return PreviewResult(
+                operation=op,
+                description=f"CREATE {op.file} ({len(op.content)} lines)",
+                warnings=warnings
+            )
+
+        elif op.type == OperationType.DELETE:
+            if not file_path.exists():
+                warnings.append(f"File does not exist")
+                return PreviewResult(
+                    operation=op,
+                    description=f"DELETE {op.file} Z{op.start_line}-Z{op.end_line} (file not found)",
+                    warnings=warnings
+                )
+
+            old_lines = self._read_file_lines(file_path)
+            if op.end_line > len(old_lines):
+                warnings.append(f"Line range exceeds file length ({len(old_lines)} lines)")
+
+            new_lines = old_lines.copy()
+            start_idx = op.start_line - 1
+            end_idx = min(op.end_line, len(old_lines))
+            del new_lines[start_idx:end_idx]
+
+            diff = self.diff_generator.generate(old_lines, new_lines, op.file)
+            return PreviewResult(
+                operation=op,
+                description=f"DELETE {op.file} Z{op.start_line}-Z{op.end_line}",
+                diff=diff,
+                warnings=warnings
+            )
+
+        elif op.type == OperationType.INSERT_AFTER:
+            if not file_path.exists():
+                warnings.append(f"File does not exist")
+                return PreviewResult(
+                    operation=op,
+                    description=f"INSERT_AFTER {op.file} Z{op.start_line} (file not found)",
+                    warnings=warnings
+                )
+
+            old_lines = self._read_file_lines(file_path)
+            if op.start_line > len(old_lines):
+                warnings.append(f"Line {op.start_line} exceeds file length ({len(old_lines)} lines)")
+
+            new_lines = old_lines.copy()
+            insert_idx = min(op.start_line, len(old_lines))
+            for i, line in enumerate(op.content):
+                new_lines.insert(insert_idx + i, line)
+
+            diff = self.diff_generator.generate(old_lines, new_lines, op.file)
+            return PreviewResult(
+                operation=op,
+                description=f"INSERT_AFTER {op.file} Z{op.start_line} ({len(op.content)} lines)",
+                diff=diff,
+                warnings=warnings
+            )
+
+        elif op.type == OperationType.REPLACE:
+            if not file_path.exists():
+                warnings.append(f"File does not exist")
+                return PreviewResult(
+                    operation=op,
+                    description=f"REPLACE {op.file} Z{op.start_line}-Z{op.end_line} (file not found)",
+                    warnings=warnings
+                )
+
+            old_lines = self._read_file_lines(file_path)
+            if op.end_line > len(old_lines):
+                warnings.append(f"Line range exceeds file length ({len(old_lines)} lines)")
+
+            new_lines = old_lines.copy()
+            start_idx = op.start_line - 1
+            end_idx = min(op.end_line, len(old_lines))
+            new_lines[start_idx:end_idx] = op.content
+
+            diff = self.diff_generator.generate(old_lines, new_lines, op.file)
+            return PreviewResult(
+                operation=op,
+                description=f"REPLACE {op.file} Z{op.start_line}-Z{op.end_line} ({len(op.content)} lines)",
+                diff=diff,
+                warnings=warnings
+            )
+
+        elif op.type == OperationType.RENUMBER:
+            return PreviewResult(
+                operation=op,
+                description=f"RENUMBER {op.file}",
+                warnings=warnings
+            )
+
+        return PreviewResult(
+            operation=op,
+            description=f"UNKNOWN {op.type}",
+            warnings=["Unknown operation type"]
+        )
+
+    def execute(
+        self,
+        operations: list[Operation],
+        skip_checksum_mismatch: bool = False
+    ) -> list[ExecutionResult]:
+        """
+        Execute a list of operations.
+
+        Args:
+            operations: List of operations to execute
+            skip_checksum_mismatch: Continue even if checksums don't match
+
+        Returns:
+            List of execution results
+        """
+        results = []
+
+        # Start backup session
+        self.backup_manager.start_session()
+
+        try:
+            for op in operations:
+                result = self._execute_operation(op, skip_checksum_mismatch)
+                results.append(result)
+
+                # Stop on error
+                if result.status == ResultStatus.ERROR:
+                    break
+
+        finally:
+            # End backup session
+            self.backup_manager.end_session()
+
+        return results
+
+    def _execute_operation(
+        self,
+        op: Operation,
+        skip_checksum_mismatch: bool = False
+    ) -> ExecutionResult:
+        """Execute a single operation."""
+        file_path = self.project_path / op.file
+
+        try:
+            if op.type == OperationType.NEW:
+                return self._execute_new(op, file_path)
+            elif op.type == OperationType.DELETE:
+                return self._execute_delete(op, file_path, skip_checksum_mismatch)
+            elif op.type == OperationType.INSERT_AFTER:
+                return self._execute_insert_after(op, file_path, skip_checksum_mismatch)
+            elif op.type == OperationType.REPLACE:
+                return self._execute_replace(op, file_path, skip_checksum_mismatch)
+            elif op.type == OperationType.RENUMBER:
+                return self._execute_renumber(op, file_path)
+            else:
+                return ExecutionResult(
+                    status=ResultStatus.ERROR,
+                    operation=op,
+                    message=f"Unknown operation type: {op.type}"
+                )
+        except PermissionError:
+            return ExecutionResult(
+                status=ResultStatus.ERROR,
+                operation=op,
+                message=f"Permission denied: {file_path}"
+            )
+        except Exception as e:
+            return ExecutionResult(
+                status=ResultStatus.ERROR,
+                operation=op,
+                message=f"Error: {str(e)}"
+            )
+
+    def _execute_new(self, op: Operation, file_path: Path) -> ExecutionResult:
+        """Execute a NEW operation (create file)."""
+        # Backup if file exists
+        if file_path.exists():
+            self.backup_manager.backup(str(op.file))
+
+        # Create parent directories
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write content
+        content = "\n".join(op.content)
+        if op.content and not content.endswith("\n"):
+            content += "\n"
+        file_path.write_text(content)
+
+        return ExecutionResult(
+            status=ResultStatus.SUCCESS,
+            operation=op,
+            message=f"CREATE {op.file} ({len(op.content)} lines)"
+        )
+
+    def _execute_delete(
+        self,
+        op: Operation,
+        file_path: Path,
+        skip_checksum_mismatch: bool
+    ) -> ExecutionResult:
+        """Execute a DELETE operation."""
+        if not file_path.exists():
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"File not found: {op.file}"
+            )
+
+        # Validate checksum if provided
+        if op.checksum and self.validate_checksums:
+            if not self._validate_checksum(file_path, op.checksum):
+                if not skip_checksum_mismatch:
+                    return ExecutionResult(
+                        status=ResultStatus.WARNING,
+                        operation=op,
+                        message=f"Checksum mismatch for {op.file} - file was modified externally"
+                    )
+
+        # Backup file
+        self.backup_manager.backup(str(op.file))
+
+        # Read file and delete lines
+        lines = self._read_file_lines(file_path)
+        old_lines = lines.copy()
+
+        if op.end_line > len(lines):
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"Line range Z{op.start_line}-Z{op.end_line} exceeds file length ({len(lines)} lines)"
+            )
+
+        start_idx = op.start_line - 1
+        end_idx = op.end_line
+        del lines[start_idx:end_idx]
+
+        # Write back
+        self._write_file_lines(file_path, lines)
+
+        diff = self.diff_generator.generate(old_lines, lines, op.file)
+
+        return ExecutionResult(
+            status=ResultStatus.SUCCESS,
+            operation=op,
+            message=f"DELETE {op.file} Z{op.start_line}-Z{op.end_line}",
+            diff=diff
+        )
+
+    def _execute_insert_after(
+        self,
+        op: Operation,
+        file_path: Path,
+        skip_checksum_mismatch: bool
+    ) -> ExecutionResult:
+        """Execute an INSERT_AFTER operation."""
+        if not file_path.exists():
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"File not found: {op.file}"
+            )
+
+        # Validate checksum if provided
+        if op.checksum and self.validate_checksums:
+            if not self._validate_checksum(file_path, op.checksum):
+                if not skip_checksum_mismatch:
+                    return ExecutionResult(
+                        status=ResultStatus.WARNING,
+                        operation=op,
+                        message=f"Checksum mismatch for {op.file} - file was modified externally"
+                    )
+
+        # Backup file
+        self.backup_manager.backup(str(op.file))
+
+        # Read file and insert lines
+        lines = self._read_file_lines(file_path)
+        old_lines = lines.copy()
+
+        if op.start_line > len(lines):
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"Line Z{op.start_line} exceeds file length ({len(lines)} lines)"
+            )
+
+        insert_idx = op.start_line
+        for i, line in enumerate(op.content):
+            lines.insert(insert_idx + i, line)
+
+        # Write back
+        self._write_file_lines(file_path, lines)
+
+        diff = self.diff_generator.generate(old_lines, lines, op.file)
+
+        return ExecutionResult(
+            status=ResultStatus.SUCCESS,
+            operation=op,
+            message=f"INSERT_AFTER {op.file} Z{op.start_line} ({len(op.content)} lines)",
+            diff=diff
+        )
+
+    def _execute_replace(
+        self,
+        op: Operation,
+        file_path: Path,
+        skip_checksum_mismatch: bool
+    ) -> ExecutionResult:
+        """Execute a REPLACE operation."""
+        if not file_path.exists():
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"File not found: {op.file}"
+            )
+
+        # Validate checksum if provided
+        if op.checksum and self.validate_checksums:
+            if not self._validate_checksum(file_path, op.checksum):
+                if not skip_checksum_mismatch:
+                    return ExecutionResult(
+                        status=ResultStatus.WARNING,
+                        operation=op,
+                        message=f"Checksum mismatch for {op.file} - file was modified externally"
+                    )
+
+        # Backup file
+        self.backup_manager.backup(str(op.file))
+
+        # Read file and replace lines
+        lines = self._read_file_lines(file_path)
+        old_lines = lines.copy()
+
+        if op.end_line > len(lines):
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"Line range Z{op.start_line}-Z{op.end_line} exceeds file length ({len(lines)} lines)"
+            )
+
+        start_idx = op.start_line - 1
+        end_idx = op.end_line
+        lines[start_idx:end_idx] = op.content
+
+        # Write back
+        self._write_file_lines(file_path, lines)
+
+        diff = self.diff_generator.generate(old_lines, lines, op.file)
+
+        return ExecutionResult(
+            status=ResultStatus.SUCCESS,
+            operation=op,
+            message=f"REPLACE {op.file} Z{op.start_line}-Z{op.end_line} ({len(op.content)} lines)",
+            diff=diff
+        )
+
+    def _execute_renumber(self, op: Operation, file_path: Path) -> ExecutionResult:
+        """Execute a RENUMBER operation."""
+        if not file_path.exists():
+            return ExecutionResult(
+                status=ResultStatus.WARNING,
+                operation=op,
+                message=f"File not found: {op.file}"
+            )
+
+        # No backup needed for renumber (just updates line numbers)
+        lines = self._read_file_lines(file_path)
+        renumbered_lines = []
+
+        for i, line in enumerate(lines, 1):
+            # Remove existing line number
+            clean_line = self._remove_line_number(line)
+            # Add new line number
+            suffix = self.parser.get_line_number_suffix(op.file, i)
+            renumbered_lines.append(clean_line + suffix)
+
+        self._write_file_lines(file_path, renumbered_lines)
+
+        return ExecutionResult(
+            status=ResultStatus.SUCCESS,
+            operation=op,
+            message=f"RENUMBER {op.file} ({len(lines)} lines)"
+        )
+
+    def _read_file_lines(self, file_path: Path) -> list[str]:
+        """Read file and return lines without trailing newlines."""
+        content = file_path.read_text()
+        lines = content.split('\n')
+        # Remove trailing empty line if file ends with newline
+        if lines and lines[-1] == '':
+            lines = lines[:-1]
+        return lines
+
+    def _write_file_lines(self, file_path: Path, lines: list[str]) -> None:
+        """Write lines to file with trailing newline."""
+        content = '\n'.join(lines)
+        if lines and not content.endswith('\n'):
+            content += '\n'
+        file_path.write_text(content)
+
+    def _remove_line_number(self, line: str) -> str:
+        """Remove line number marker from end of line."""
+        for pattern in self.LINE_NUMBER_PATTERNS:
+            match = pattern.search(line)
+            if match:
+                return line[:match.start()]
+        return line
+
+    def _validate_checksum(self, file_path: Path, expected: str) -> bool:
+        """Validate file checksum."""
+        content = file_path.read_bytes()
+        actual = hashlib.md5(content).hexdigest()[:8]
+        return actual.lower() == expected.lower()
+
+    @staticmethod
+    def calculate_checksum(file_path: Path) -> str:
+        """Calculate checksum for a file."""
+        content = file_path.read_bytes()
+        return hashlib.md5(content).hexdigest()[:8]
+
+
+def main():
+    """Test the executor."""
+    import tempfile
+
+    test_input = """###FILE:calculator.py
+###NEW
+def add(a, b):  #Z1
+    return a + b  #Z2
+  #Z3
+def multiply(a, b):  #Z4
+    return a * b  #Z5
+###END
+"""
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        parser = DCTPParser()
+        result = parser.parse(test_input)
+
+        print("Parsed operations:")
+        for op in result.operations:
+            print(f"  {op}")
+
+        executor = DCTPExecutor(tmpdir)
+
+        # Preview
+        print("\nPreviews:")
+        previews = executor.preview(result.operations)
+        for preview in previews:
+            print(f"  {preview.description}")
+            if preview.warnings:
+                for w in preview.warnings:
+                    print(f"    ⚠️ {w}")
+
+        # Execute
+        print("\nExecution:")
+        exec_results = executor.execute(result.operations)
+        for r in exec_results:
+            print(f"  {r}")
+
+        # Verify file was created
+        file_path = Path(tmpdir) / "calculator.py"
+        if file_path.exists():
+            print(f"\nFile content:\n{file_path.read_text()}")
+
+
+if __name__ == "__main__":
+    main()

dctp/dctp_gui.py

@@ -0,0 +1,666 @@
+#!/usr/bin/env python3
+"""
+DCTP GUI - Delta Code Transfer Protocol graphical user interface.
+
+A CustomTkinter-based GUI for managing AI-generated code transfers
+using delta operations for efficient updates.
+"""
+
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from tkinter import filedialog, messagebox
+from typing import Optional
+import json
+
+import customtkinter as ctk
+
+from dctp_parser import DCTPParser, ParseResult, Operation, OperationType
+from dctp_executor import DCTPExecutor, ExecutionResult, PreviewResult, ResultStatus
+from dctp_backup import BackupManager
+from dctp_diff import DiffType
+
+
+class SettingsDialog(ctk.CTkToplevel):
+    """Settings dialog window."""
+
+    def __init__(self, parent, settings: dict):
+        super().__init__(parent)
+
+        self.title("Einstellungen")
+        self.geometry("500x400")
+        self.resizable(False, False)
+
+        self.settings = settings.copy()
+        self.result = None
+
+        # Make modal
+        self.transient(parent)
+        self.grab_set()
+
+        self._create_widgets()
+
+        # Center on parent
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() - self.winfo_width()) // 2
+        y = parent.winfo_y() + (parent.winfo_height() - self.winfo_height()) // 2
+        self.geometry(f"+{x}+{y}")
+
+    def _create_widgets(self):
+        # Main frame
+        main_frame = ctk.CTkFrame(self)
+        main_frame.pack(fill="both", expand=True, padx=20, pady=20)
+
+        # Project path
+        ctk.CTkLabel(main_frame, text="Standard-Projektpfad:").pack(anchor="w", pady=(0, 5))
+        path_frame = ctk.CTkFrame(main_frame)
+        path_frame.pack(fill="x", pady=(0, 15))
+
+        self.path_entry = ctk.CTkEntry(path_frame, width=350)
+        self.path_entry.pack(side="left", fill="x", expand=True, padx=(0, 10))
+        self.path_entry.insert(0, self.settings.get("project_path", ""))
+
+        ctk.CTkButton(
+            path_frame,
+            text="...",
+            width=40,
+            command=self._browse_path
+        ).pack(side="right")
+
+        # Backup directory
+        ctk.CTkLabel(main_frame, text="Backup-Verzeichnis:").pack(anchor="w", pady=(0, 5))
+        backup_frame = ctk.CTkFrame(main_frame)
+        backup_frame.pack(fill="x", pady=(0, 15))
+
+        self.backup_entry = ctk.CTkEntry(backup_frame, width=350)
+        self.backup_entry.pack(side="left", fill="x", expand=True, padx=(0, 10))
+        self.backup_entry.insert(0, self.settings.get("backup_dir", ".dctp_backups"))
+
+        ctk.CTkButton(
+            backup_frame,
+            text="...",
+            width=40,
+            command=self._browse_backup
+        ).pack(side="right")
+
+        # Options
+        options_frame = ctk.CTkFrame(main_frame)
+        options_frame.pack(fill="x", pady=15)
+
+        self.auto_renumber_var = ctk.BooleanVar(
+            value=self.settings.get("auto_renumber", True)
+        )
+        ctk.CTkCheckBox(
+            options_frame,
+            text="Auto-Renumber nach Operationen",
+            variable=self.auto_renumber_var
+        ).pack(anchor="w", pady=5)
+
+        self.validate_checksum_var = ctk.BooleanVar(
+            value=self.settings.get("validate_checksum", True)
+        )
+        ctk.CTkCheckBox(
+            options_frame,
+            text="Checksum-Validierung aktiviert",
+            variable=self.validate_checksum_var
+        ).pack(anchor="w", pady=5)
+
+        # Theme
+        ctk.CTkLabel(main_frame, text="Theme:").pack(anchor="w", pady=(15, 5))
+        self.theme_var = ctk.StringVar(value=self.settings.get("theme", "dark"))
+        theme_frame = ctk.CTkFrame(main_frame)
+        theme_frame.pack(fill="x", pady=(0, 15))
+
+        ctk.CTkRadioButton(
+            theme_frame,
+            text="Dunkel",
+            variable=self.theme_var,
+            value="dark"
+        ).pack(side="left", padx=(0, 20))
+
+        ctk.CTkRadioButton(
+            theme_frame,
+            text="Hell",
+            variable=self.theme_var,
+            value="light"
+        ).pack(side="left")
+
+        # Buttons
+        button_frame = ctk.CTkFrame(main_frame)
+        button_frame.pack(fill="x", pady=(20, 0))
+
+        ctk.CTkButton(
+            button_frame,
+            text="Abbrechen",
+            command=self._cancel
+        ).pack(side="right", padx=(10, 0))
+
+        ctk.CTkButton(
+            button_frame,
+            text="Speichern",
+            command=self._save
+        ).pack(side="right")
+
+    def _browse_path(self):
+        path = filedialog.askdirectory(
+            initialdir=self.path_entry.get() or os.path.expanduser("~")
+        )
+        if path:
+            self.path_entry.delete(0, "end")
+            self.path_entry.insert(0, path)
+
+    def _browse_backup(self):
+        path = filedialog.askdirectory(
+            initialdir=os.path.expanduser("~")
+        )
+        if path:
+            self.backup_entry.delete(0, "end")
+            self.backup_entry.insert(0, path)
+
+    def _save(self):
+        self.result = {
+            "project_path": self.path_entry.get(),
+            "backup_dir": self.backup_entry.get(),
+            "auto_renumber": self.auto_renumber_var.get(),
+            "validate_checksum": self.validate_checksum_var.get(),
+            "theme": self.theme_var.get()
+        }
+        self.destroy()
+
+    def _cancel(self):
+        self.result = None
+        self.destroy()
+
+
+class DCTPApp(ctk.CTk):
+    """Main DCTP application window."""
+
+    SETTINGS_FILE = ".dctp_settings.json"
+
+    def __init__(self):
+        super().__init__()
+
+        self.title("DCTP - Delta Code Transfer")
+        self.geometry("1200x900")
+        self.minsize(800, 600)
+
+        # Initialize components
+        self.parser = DCTPParser()
+        self.executor: Optional[DCTPExecutor] = None
+        self.backup_manager: Optional[BackupManager] = None
+        self.current_operations: list[Operation] = []
+        self.current_previews: list[PreviewResult] = []
+
+        # Load settings
+        self.settings = self._load_settings()
+        ctk.set_appearance_mode(self.settings.get("theme", "dark"))
+
+        # Create UI
+        self._create_widgets()
+
+        # Initialize project if path is set
+        if self.settings.get("project_path"):
+            self._init_project(self.settings["project_path"])
+
+        self._log("Bereit")
+
+    def _load_settings(self) -> dict:
+        """Load settings from file."""
+        settings_path = Path.home() / self.SETTINGS_FILE
+        if settings_path.exists():
+            try:
+                return json.loads(settings_path.read_text())
+            except (json.JSONDecodeError, IOError):
+                pass
+        return {
+            "project_path": "",
+            "backup_dir": ".dctp_backups",
+            "auto_renumber": True,
+            "validate_checksum": True,
+            "theme": "dark"
+        }
+
+    def _save_settings(self):
+        """Save settings to file."""
+        settings_path = Path.home() / self.SETTINGS_FILE
+        settings_path.write_text(json.dumps(self.settings, indent=2))
+
+    def _create_widgets(self):
+        """Create all UI widgets."""
+        # Top bar - project selection
+        top_frame = ctk.CTkFrame(self)
+        top_frame.pack(fill="x", padx=10, pady=10)
+
+        ctk.CTkLabel(top_frame, text="Projekt:").pack(side="left", padx=(0, 10))
+
+        self.project_entry = ctk.CTkEntry(top_frame, width=400)
+        self.project_entry.pack(side="left", fill="x", expand=True, padx=(0, 10))
+        self.project_entry.insert(0, self.settings.get("project_path", ""))
+
+        ctk.CTkButton(
+            top_frame,
+            text="Waehlen",
+            width=100,
+            command=self._browse_project
+        ).pack(side="left", padx=(0, 10))
+
+        ctk.CTkButton(
+            top_frame,
+            text="Einstellungen",
+            width=100,
+            command=self._open_settings
+        ).pack(side="left")
+
+        # Main content area with paned layout
+        content_frame = ctk.CTkFrame(self)
+        content_frame.pack(fill="both", expand=True, padx=10, pady=(0, 10))
+
+        # Left side - Input and preview
+        left_frame = ctk.CTkFrame(content_frame)
+        left_frame.pack(side="left", fill="both", expand=True, padx=(0, 5))
+
+        # Input area
+        input_label_frame = ctk.CTkFrame(left_frame)
+        input_label_frame.pack(fill="x", pady=(5, 5), padx=5)
+        ctk.CTkLabel(
+            input_label_frame,
+            text="Input (KI-Output hier einfuegen)",
+            font=ctk.CTkFont(weight="bold")
+        ).pack(side="left")
+
+        self.input_text = ctk.CTkTextbox(
+            left_frame,
+            height=250,
+            font=ctk.CTkFont(family="Consolas", size=12)
+        )
+        self.input_text.pack(fill="both", expand=True, padx=5, pady=(0, 10))
+
+        # Buttons
+        button_frame = ctk.CTkFrame(left_frame)
+        button_frame.pack(fill="x", padx=5, pady=(0, 10))
+
+        self.analyze_btn = ctk.CTkButton(
+            button_frame,
+            text="Analysieren",
+            command=self._analyze,
+            width=120
+        )
+        self.analyze_btn.pack(side="left", padx=(0, 10))
+
+        self.execute_btn = ctk.CTkButton(
+            button_frame,
+            text="Ausfuehren",
+            command=self._execute,
+            width=120,
+            state="disabled"
+        )
+        self.execute_btn.pack(side="left", padx=(0, 10))
+
+        self.undo_btn = ctk.CTkButton(
+            button_frame,
+            text="Undo",
+            command=self._undo,
+            width=80
+        )
+        self.undo_btn.pack(side="left", padx=(0, 10))
+
+        ctk.CTkButton(
+            button_frame,
+            text="Clear",
+            command=self._clear,
+            width=80
+        ).pack(side="left")
+
+        # Preview operations
+        preview_label_frame = ctk.CTkFrame(left_frame)
+        preview_label_frame.pack(fill="x", pady=(5, 5), padx=5)
+        ctk.CTkLabel(
+            preview_label_frame,
+            text="Vorschau Operationen",
+            font=ctk.CTkFont(weight="bold")
+        ).pack(side="left")
+
+        self.preview_text = ctk.CTkTextbox(
+            left_frame,
+            height=150,
+            font=ctk.CTkFont(family="Consolas", size=11)
+        )
+        self.preview_text.pack(fill="both", expand=True, padx=5, pady=(0, 10))
+        self.preview_text.configure(state="disabled")
+
+        # Right side - Diff and file tree
+        right_frame = ctk.CTkFrame(content_frame)
+        right_frame.pack(side="right", fill="both", expand=True, padx=(5, 0))
+
+        # Diff view
+        diff_label_frame = ctk.CTkFrame(right_frame)
+        diff_label_frame.pack(fill="x", pady=(5, 5), padx=5)
+        ctk.CTkLabel(
+            diff_label_frame,
+            text="Diff-Ansicht",
+            font=ctk.CTkFont(weight="bold")
+        ).pack(side="left")
+
+        self.diff_text = ctk.CTkTextbox(
+            right_frame,
+            height=300,
+            font=ctk.CTkFont(family="Consolas", size=11)
+        )
+        self.diff_text.pack(fill="both", expand=True, padx=5, pady=(0, 10))
+        self.diff_text.configure(state="disabled")
+
+        # File tree
+        tree_label_frame = ctk.CTkFrame(right_frame)
+        tree_label_frame.pack(fill="x", pady=(5, 5), padx=5)
+        ctk.CTkLabel(
+            tree_label_frame,
+            text="Projektdateien",
+            font=ctk.CTkFont(weight="bold")
+        ).pack(side="left")
+
+        ctk.CTkButton(
+            tree_label_frame,
+            text="Aktualisieren",
+            width=80,
+            command=self._refresh_file_tree
+        ).pack(side="right")
+
+        self.tree_text = ctk.CTkTextbox(
+            right_frame,
+            height=150,
+            font=ctk.CTkFont(family="Consolas", size=11)
+        )
+        self.tree_text.pack(fill="both", expand=True, padx=5, pady=(0, 10))
+        self.tree_text.configure(state="disabled")
+
+        # Bottom - Log
+        log_label_frame = ctk.CTkFrame(self)
+        log_label_frame.pack(fill="x", padx=10, pady=(0, 5))
+        ctk.CTkLabel(
+            log_label_frame,
+            text="Log",
+            font=ctk.CTkFont(weight="bold")
+        ).pack(side="left")
+
+        self.log_text = ctk.CTkTextbox(
+            self,
+            height=120,
+            font=ctk.CTkFont(family="Consolas", size=10)
+        )
+        self.log_text.pack(fill="x", padx=10, pady=(0, 10))
+        self.log_text.configure(state="disabled")
+
+    def _log(self, message: str, level: str = "info"):
+        """Add a message to the log."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        prefix = ""
+        if level == "error":
+            prefix = "ERROR "
+        elif level == "warning":
+            prefix = "WARN  "
+
+        self.log_text.configure(state="normal")
+        self.log_text.insert("end", f"{timestamp}  {prefix}{message}\n")
+        self.log_text.see("end")
+        self.log_text.configure(state="disabled")
+
+    def _init_project(self, path: str):
+        """Initialize project with given path."""
+        if not os.path.isdir(path):
+            self._log(f"Verzeichnis existiert nicht: {path}", "error")
+            return False
+
+        self.backup_manager = BackupManager(path)
+        self.executor = DCTPExecutor(
+            path,
+            self.backup_manager,
+            auto_renumber=self.settings.get("auto_renumber", True),
+            validate_checksums=self.settings.get("validate_checksum", True)
+        )
+        self.settings["project_path"] = path
+        self._save_settings()
+        self._log(f"Projekt geladen: {path}")
+        self._refresh_file_tree()
+        return True
+
+    def _browse_project(self):
+        """Open directory browser for project selection."""
+        initial_dir = self.project_entry.get() or os.path.expanduser("~")
+        path = filedialog.askdirectory(initialdir=initial_dir)
+        if path:
+            self.project_entry.delete(0, "end")
+            self.project_entry.insert(0, path)
+            self._init_project(path)
+
+    def _open_settings(self):
+        """Open settings dialog."""
+        dialog = SettingsDialog(self, self.settings)
+        self.wait_window(dialog)
+
+        if dialog.result:
+            old_theme = self.settings.get("theme")
+            self.settings.update(dialog.result)
+            self._save_settings()
+
+            # Apply theme change
+            if dialog.result.get("theme") != old_theme:
+                ctk.set_appearance_mode(dialog.result["theme"])
+
+            # Reinitialize project with new settings
+            if self.settings.get("project_path"):
+                self._init_project(self.settings["project_path"])
+
+            self._log("Einstellungen gespeichert")
+
+    def _analyze(self):
+        """Analyze input and show preview."""
+        # Ensure project is initialized
+        project_path = self.project_entry.get()
+        if not project_path:
+            messagebox.showerror("Fehler", "Bitte waehle ein Projektverzeichnis")
+            return
+
+        if not self.executor or self.settings.get("project_path") != project_path:
+            if not self._init_project(project_path):
+                return
+
+        # Get input
+        input_text = self.input_text.get("1.0", "end-1c")
+        if not input_text.strip():
+            self._log("Kein Input vorhanden", "warning")
+            return
+
+        # Parse
+        self._log("Analysiere...")
+        result = self.parser.parse(input_text)
+
+        # Handle errors
+        if result.has_errors:
+            self._log(f"{len(result.errors)} Parse-Fehler gefunden", "error")
+            for error in result.errors:
+                self._log(f"  Zeile {error.line_number}: {error.message}", "error")
+            return
+
+        if not result.operations:
+            self._log("Keine Operationen gefunden", "warning")
+            return
+
+        self.current_operations = result.operations
+        self._log(f"{len(result.operations)} Operationen gefunden")
+
+        # Generate previews
+        self.current_previews = self.executor.preview(result.operations)
+
+        # Display previews
+        self._display_previews()
+
+        # Enable execute button
+        self.execute_btn.configure(state="normal")
+
+    def _display_previews(self):
+        """Display operation previews."""
+        self.preview_text.configure(state="normal")
+        self.preview_text.delete("1.0", "end")
+
+        self.diff_text.configure(state="normal")
+        self.diff_text.delete("1.0", "end")
+
+        for preview in self.current_previews:
+            # Add to preview list
+            self.preview_text.insert("end", f"{preview.description}\n")
+            for warning in preview.warnings:
+                self.preview_text.insert("end", f"  WARNING {warning}\n")
+
+            # Add diff if available
+            if preview.diff and preview.diff.has_changes:
+                self.diff_text.insert("end", f"--- {preview.diff.filename} ---\n")
+                for line in preview.diff.lines:
+                    if line.type == DiffType.ADDED:
+                        self.diff_text.insert("end", f"+ {line.content}\n")
+                    elif line.type == DiffType.REMOVED:
+                        self.diff_text.insert("end", f"- {line.content}\n")
+                    elif line.type == DiffType.UNCHANGED:
+                        self.diff_text.insert("end", f"  {line.content}\n")
+                self.diff_text.insert("end", "\n")
+
+        self.preview_text.configure(state="disabled")
+        self.diff_text.configure(state="disabled")
+
+    def _execute(self):
+        """Execute the analyzed operations."""
+        if not self.current_operations:
+            self._log("Keine Operationen zum Ausfuehren", "warning")
+            return
+
+        if not self.executor:
+            self._log("Kein Projekt initialisiert", "error")
+            return
+
+        # Confirm
+        count = len(self.current_operations)
+        if not messagebox.askyesno(
+            "Bestaetigen",
+            f"{count} Operationen ausfuehren?"
+        ):
+            return
+
+        self._log(f"Fuehre {count} Operationen aus...")
+
+        # Execute
+        results = self.executor.execute(self.current_operations)
+
+        # Log results
+        success_count = 0
+        for result in results:
+            if result.status == ResultStatus.SUCCESS:
+                self._log(f"OK {result.message}")
+                success_count += 1
+            elif result.status == ResultStatus.WARNING:
+                self._log(f"WARN {result.message}", "warning")
+            elif result.status == ResultStatus.ERROR:
+                self._log(f"ERROR {result.message}", "error")
+
+        self._log(f"Abgeschlossen: {success_count}/{count} erfolgreich")
+
+        # Clear current operations
+        self.current_operations = []
+        self.current_previews = []
+        self.execute_btn.configure(state="disabled")
+
+        # Refresh file tree
+        self._refresh_file_tree()
+
+    def _undo(self):
+        """Undo last operation."""
+        if not self.backup_manager:
+            self._log("Kein Projekt initialisiert", "error")
+            return
+
+        success, restored = self.backup_manager.restore_last()
+
+        if success:
+            self._log(f"Undo erfolgreich: {len(restored)} Dateien wiederhergestellt")
+            for f in restored:
+                self._log(f"  -> {f}")
+            self._refresh_file_tree()
+        else:
+            self._log("Kein Backup zum Wiederherstellen", "warning")
+
+    def _clear(self):
+        """Clear input and preview areas."""
+        self.input_text.delete("1.0", "end")
+
+        self.preview_text.configure(state="normal")
+        self.preview_text.delete("1.0", "end")
+        self.preview_text.configure(state="disabled")
+
+        self.diff_text.configure(state="normal")
+        self.diff_text.delete("1.0", "end")
+        self.diff_text.configure(state="disabled")
+
+        self.current_operations = []
+        self.current_previews = []
+        self.execute_btn.configure(state="disabled")
+
+        self._log("Eingabe geloescht")
+
+    def _refresh_file_tree(self):
+        """Refresh the file tree display."""
+        self.tree_text.configure(state="normal")
+        self.tree_text.delete("1.0", "end")
+
+        project_path = self.project_entry.get()
+        if not project_path or not os.path.isdir(project_path):
+            self.tree_text.insert("end", "(Kein Projekt geladen)")
+            self.tree_text.configure(state="disabled")
+            return
+
+        # Build simple tree
+        try:
+            self._add_tree_items(Path(project_path), 0)
+        except Exception as e:
+            self.tree_text.insert("end", f"Fehler: {e}")
+
+        self.tree_text.configure(state="disabled")
+
+    def _add_tree_items(self, path: Path, level: int, max_items: int = 100):
+        """Recursively add items to tree display."""
+        if level > 5:  # Limit depth
+            return
+
+        indent = "  " * level
+
+        try:
+            items = sorted(path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+            count = 0
+
+            for item in items:
+                if count >= max_items:
+                    self.tree_text.insert("end", f"{indent}  ... (mehr Dateien)\n")
+                    break
+
+                # Skip hidden files and backup directory
+                if item.name.startswith('.'):
+                    continue
+
+                if item.is_dir():
+                    self.tree_text.insert("end", f"{indent}DIR {item.name}/\n")
+                    self._add_tree_items(item, level + 1, max_items=20)
+                else:
+                    self.tree_text.insert("end", f"{indent}FILE {item.name}\n")
+
+                count += 1
+
+        except PermissionError:
+            self.tree_text.insert("end", f"{indent}  (Zugriff verweigert)\n")
+
+
+def main():
+    """Main entry point."""
+    app = DCTPApp()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()

dctp/dctp_parser.py

@@ -0,0 +1,307 @@
+"""
+DCTP Parser - Parses DCTP control commands and code blocks.
+
+Handles line-numbered code with language-specific comment formats:
+- Python/Shell: #Z1
+- JavaScript/Java/C/C++: //Z1
+- HTML: <!--Z1-->
+- CSS: /*Z1*/
+- SQL: --Z1
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+from enum import Enum
+
+
+class OperationType(Enum):
+    NEW = "NEW"
+    DELETE = "DELETE"
+    INSERT_AFTER = "INSERT_AFTER"
+    REPLACE = "REPLACE"
+    RENUMBER = "RENUMBER"
+
+
+@dataclass
+class Operation:
+    """Represents a single DCTP operation."""
+    type: OperationType
+    file: str
+    start_line: Optional[int] = None
+    end_line: Optional[int] = None
+    content: list[str] = field(default_factory=list)
+    checksum: Optional[str] = None
+    raw_content: list[str] = field(default_factory=list)  # Content with line numbers
+
+    def __str__(self) -> str:
+        if self.type == OperationType.NEW:
+            return f"CREATE {self.file} ({len(self.content)} lines)"
+        elif self.type == OperationType.DELETE:
+            return f"DELETE {self.file} Z{self.start_line}-Z{self.end_line}"
+        elif self.type == OperationType.INSERT_AFTER:
+            return f"INSERT_AFTER {self.file} Z{self.start_line} ({len(self.content)} lines)"
+        elif self.type == OperationType.REPLACE:
+            return f"REPLACE {self.file} Z{self.start_line}-Z{self.end_line} ({len(self.content)} lines)"
+        elif self.type == OperationType.RENUMBER:
+            return f"RENUMBER {self.file}"
+        return f"{self.type.value} {self.file}"
+
+
+@dataclass
+class ParseError:
+    """Represents a parsing error."""
+    line_number: int
+    line_content: str
+    message: str
+
+
+@dataclass
+class ParseResult:
+    """Result of parsing DCTP input."""
+    operations: list[Operation]
+    errors: list[ParseError]
+
+    @property
+    def has_errors(self) -> bool:
+        return len(self.errors) > 0
+
+
+class DCTPParser:
+    """Parser for DCTP (Delta Code Transfer Protocol) format."""
+
+    # Regex patterns for line number markers in different languages
+    LINE_NUMBER_PATTERNS = [
+        re.compile(r'\s*#Z(\d+)\s*$'),           # Python, Shell
+        re.compile(r'\s*//Z(\d+)\s*$'),          # JavaScript, Java, C, C++
+        re.compile(r'\s*<!--Z(\d+)-->\s*$'),     # HTML
+        re.compile(r'\s*/\*Z(\d+)\*/\s*$'),      # CSS
+        re.compile(r'\s*--Z(\d+)\s*$'),          # SQL
+    ]
+
+    # Control command patterns
+    FILE_PATTERN = re.compile(r'^###FILE:(.+)$')
+    NEW_PATTERN = re.compile(r'^###NEW\s*$')
+    DELETE_PATTERN = re.compile(r'^###DELETE:Z(\d+)(?:-Z(\d+))?\s*$')
+    INSERT_AFTER_PATTERN = re.compile(r'^###INSERT_AFTER:Z(\d+)\s*$')
+    REPLACE_PATTERN = re.compile(r'^###REPLACE:Z(\d+)(?:-Z(\d+))?\s*$')
+    END_PATTERN = re.compile(r'^###END\s*$')
+    RENUMBER_PATTERN = re.compile(r'^###RENUMBER\s*$')
+    CHECKSUM_PATTERN = re.compile(r'^###CHECKSUM:([a-fA-F0-9]+)\s*$')
+
+    def parse(self, text: str) -> ParseResult:
+        """
+        Parse DCTP formatted text into a list of operations.
+
+        Args:
+            text: The DCTP formatted input text
+
+        Returns:
+            ParseResult containing operations and any errors
+        """
+        operations: list[Operation] = []
+        errors: list[ParseError] = []
+
+        current_file: Optional[str] = None
+        current_op: Optional[Operation] = None
+        buffer: list[str] = []
+        raw_buffer: list[str] = []
+
+        lines = text.split('\n')
+
+        for line_num, line in enumerate(lines, 1):
+            # Skip empty lines outside of content blocks
+            if not line.strip() and current_op is None:
+                continue
+
+            # Check for FILE command
+            file_match = self.FILE_PATTERN.match(line)
+            if file_match:
+                current_file = file_match.group(1).strip()
+                continue
+
+            # Check for NEW command
+            if self.NEW_PATTERN.match(line):
+                if current_file is None:
+                    errors.append(ParseError(line_num, line, "###NEW without ###FILE"))
+                    continue
+                current_op = Operation(type=OperationType.NEW, file=current_file)
+                buffer = []
+                raw_buffer = []
+                continue
+
+            # Check for DELETE command
+            delete_match = self.DELETE_PATTERN.match(line)
+            if delete_match:
+                if current_file is None:
+                    errors.append(ParseError(line_num, line, "###DELETE without ###FILE"))
+                    continue
+                start = int(delete_match.group(1))
+                end = int(delete_match.group(2)) if delete_match.group(2) else start
+                operations.append(Operation(
+                    type=OperationType.DELETE,
+                    file=current_file,
+                    start_line=start,
+                    end_line=end
+                ))
+                continue
+
+            # Check for INSERT_AFTER command
+            insert_match = self.INSERT_AFTER_PATTERN.match(line)
+            if insert_match:
+                if current_file is None:
+                    errors.append(ParseError(line_num, line, "###INSERT_AFTER without ###FILE"))
+                    continue
+                current_op = Operation(
+                    type=OperationType.INSERT_AFTER,
+                    file=current_file,
+                    start_line=int(insert_match.group(1))
+                )
+                buffer = []
+                raw_buffer = []
+                continue
+
+            # Check for REPLACE command
+            replace_match = self.REPLACE_PATTERN.match(line)
+            if replace_match:
+                if current_file is None:
+                    errors.append(ParseError(line_num, line, "###REPLACE without ###FILE"))
+                    continue
+                start = int(replace_match.group(1))
+                end = int(replace_match.group(2)) if replace_match.group(2) else start
+                current_op = Operation(
+                    type=OperationType.REPLACE,
+                    file=current_file,
+                    start_line=start,
+                    end_line=end
+                )
+                buffer = []
+                raw_buffer = []
+                continue
+
+            # Check for END command
+            if self.END_PATTERN.match(line):
+                if current_op:
+                    current_op.content = buffer.copy()
+                    current_op.raw_content = raw_buffer.copy()
+                    operations.append(current_op)
+                    current_op = None
+                    buffer = []
+                    raw_buffer = []
+                continue
+
+            # Check for RENUMBER command
+            if self.RENUMBER_PATTERN.match(line):
+                if current_file is None:
+                    errors.append(ParseError(line_num, line, "###RENUMBER without ###FILE"))
+                    continue
+                operations.append(Operation(type=OperationType.RENUMBER, file=current_file))
+                continue
+
+            # Check for CHECKSUM command
+            checksum_match = self.CHECKSUM_PATTERN.match(line)
+            if checksum_match:
+                if current_op:
+                    current_op.checksum = checksum_match.group(1)
+                continue
+
+            # Regular code line - add to buffer if we're in an operation
+            if current_op is not None:
+                raw_buffer.append(line)
+                clean_line = self._remove_line_number(line)
+                buffer.append(clean_line)
+
+        # Handle unclosed operation
+        if current_op is not None:
+            errors.append(ParseError(
+                len(lines),
+                "",
+                f"Unclosed operation: {current_op.type.value} for {current_op.file}"
+            ))
+
+        return ParseResult(operations=operations, errors=errors)
+
+    def _remove_line_number(self, line: str) -> str:
+        """Remove line number marker from end of line."""
+        for pattern in self.LINE_NUMBER_PATTERNS:
+            match = pattern.search(line)
+            if match:
+                return line[:match.start()]
+        return line
+
+    def extract_line_number(self, line: str) -> Optional[int]:
+        """Extract line number from a code line."""
+        for pattern in self.LINE_NUMBER_PATTERNS:
+            match = pattern.search(line)
+            if match:
+                return int(match.group(1))
+        return None
+
+    @staticmethod
+    def get_line_number_suffix(filename: str, line_num: int) -> str:
+        """Get the appropriate line number suffix for a file type."""
+        ext = filename.rsplit('.', 1)[-1].lower() if '.' in filename else ''
+
+        if ext in ('py', 'sh', 'bash', 'zsh', 'yaml', 'yml', 'toml', 'ini', 'conf', 'rb', 'pl'):
+            return f"  #Z{line_num}"
+        elif ext in ('js', 'ts', 'jsx', 'tsx', 'java', 'c', 'cpp', 'h', 'hpp', 'cs', 'go', 'rs', 'swift', 'kt', 'scala'):
+            return f"  //Z{line_num}"
+        elif ext in ('html', 'htm', 'xml', 'svg'):
+            return f"  <!--Z{line_num}-->"
+        elif ext in ('css', 'scss', 'sass', 'less'):
+            return f"  /*Z{line_num}*/"
+        elif ext in ('sql',):
+            return f"  --Z{line_num}"
+        else:
+            # Default to Python style
+            return f"  #Z{line_num}"
+
+
+def main():
+    """Test the parser with example input."""
+    test_input = """###FILE:src/calculator.py
+###NEW
+def add(a, b):  #Z1
+    return a + b  #Z2
+  #Z3
+def multiply(a, b):  #Z4
+    return a * b  #Z5
+###END
+
+###FILE:src/calculator.py
+###REPLACE:Z4-Z5
+def multiply(a, b):  #Z4
+    \"\"\"Multipliziert zwei Zahlen.\"\"\"  #Z5
+    return a * b  #Z6
+###END
+###RENUMBER
+
+###FILE:src/calculator.py
+###INSERT_AFTER:Z2
+  #Z3
+def subtract(a, b):  #Z4
+    return a - b  #Z5
+###END
+###RENUMBER
+
+###FILE:src/calculator.py
+###DELETE:Z10-Z15
+###RENUMBER
+"""
+
+    parser = DCTPParser()
+    result = parser.parse(test_input)
+
+    print("Operations found:")
+    for op in result.operations:
+        print(f"  {op}")
+
+    if result.has_errors:
+        print("\nErrors:")
+        for error in result.errors:
+            print(f"  Line {error.line_number}: {error.message}")
+            print(f"    {error.line_content}")
+
+
+if __name__ == "__main__":
+    main()

dctp/requirements.txt

@@ -0,0 +1 @@
+customtkinter>=5.2.0

familyalbums/.htaccess

@@ -0,0 +1,48 @@
+# FamilyAlbums - Apache Configuration
+
+# Security Headers
+<IfModule mod_headers.c>
+    Header set X-Content-Type-Options "nosniff"
+    Header set X-Frame-Options "SAMEORIGIN"
+    Header set X-XSS-Protection "1; mode=block"
+    Header set Referrer-Policy "strict-origin-when-cross-origin"
+</IfModule>
+
+# Deny access to config file
+<Files "config.php">
+    <IfModule mod_authz_core.c>
+        Require all denied
+    </IfModule>
+    <IfModule !mod_authz_core.c>
+        Order deny,allow
+        Deny from all
+    </IfModule>
+</Files>
+
+# Deny access to hidden files
+<FilesMatch "^\.">
+    <IfModule mod_authz_core.c>
+        Require all denied
+    </IfModule>
+    <IfModule !mod_authz_core.c>
+        Order deny,allow
+        Deny from all
+    </IfModule>
+</FilesMatch>
+
+# Enable compression
+<IfModule mod_deflate.c>
+    AddOutputFilterByType DEFLATE text/html text/plain text/css application/json application/javascript
+</IfModule>
+
+# Cache static assets
+<IfModule mod_expires.c>
+    ExpiresActive On
+    ExpiresByType image/jpeg "access plus 1 month"
+    ExpiresByType image/png "access plus 1 month"
+    ExpiresByType image/gif "access plus 1 month"
+    ExpiresByType image/webp "access plus 1 month"
+</IfModule>
+
+# Default charset
+AddDefaultCharset UTF-8

familyalbums/README.md

@@ -0,0 +1,131 @@
+# FamilyAlbums - Familien-Fotoalbum-Portal
+
+Ein einfaches, PHP-basiertes Portal zur Verwaltung und Anzeige von Familien-Fotoalben mit Links zu Nextcloud.
+
+## Features
+
+- Öffentliche Galerie-Ansicht mit Jahr/Monat-Filter
+- Stichwortsuche über Titel, Tags und Beschreibung
+- Kommentarfunktion für Familienmitglieder
+- Admin-Interface zur Albumverwaltung
+- Responsive Design (Tailwind CSS)
+- Flat-File Datenbank (JSON) - kein MySQL erforderlich
+- Spam-Schutz (Honeypot + Rate-Limiting)
+- CSRF-Schutz für Admin-Aktionen
+
+## Installation
+
+### 1. Dateien kopieren
+
+```bash
+# Auf den Webserver kopieren
+sudo cp -r familyalbums /var/www/
+
+# Berechtigungen setzen
+sudo chown -R www-data:www-data /var/www/familyalbums
+sudo chmod -R 755 /var/www/familyalbums
+sudo chmod 770 /var/www/familyalbums/data
+sudo chmod 770 /var/www/familyalbums/thumbnails
+```
+
+### 2. Admin-Passwort ändern
+
+**WICHTIG:** Das Standard-Passwort muss vor dem produktiven Einsatz geändert werden!
+
+```bash
+# Neuen Passwort-Hash generieren
+php -r "echo password_hash('DeinSicheresPasswort', PASSWORD_DEFAULT);"
+```
+
+Den generierten Hash in `config.php` eintragen:
+
+```php
+define('ADMIN_PASSWORD_HASH', '$2y$10$DEIN_GENERIERTER_HASH_HIER');
+```
+
+### 3. Apache Virtual Host (optional)
+
+```apache
+<VirtualHost *:80>
+    ServerName familyalbums.example.com
+    DocumentRoot /var/www/familyalbums
+
+    <Directory /var/www/familyalbums>
+        AllowOverride All
+        Require all granted
+    </Directory>
+</VirtualHost>
+```
+
+## Verwendung
+
+### Öffentliche Galerie
+
+- URL: `https://deine-domain.ch/`
+- Filter nach Jahr und Monat
+- Stichwortsuche
+- Kommentare zu Alben hinterlassen
+
+### Admin-Bereich
+
+- URL: `https://deine-domain.ch/admin.php`
+- Login mit dem konfigurierten Passwort
+- Alben hinzufügen, bearbeiten, löschen
+- Optional: Vorschaubilder hochladen
+- Kommentare moderieren
+
+## Datenstruktur
+
+### albums.json
+
+```json
+{
+  "albums": [
+    {
+      "id": "uuid",
+      "title": "Albumtitel",
+      "url": "https://nextcloud.../apps/photos/public/...",
+      "date": "2024-12-25",
+      "tags": ["tag1", "tag2"],
+      "description": "Beschreibung",
+      "thumbnail": "thumbnails/bild.jpg",
+      "created_at": "2024-12-26T10:00:00+01:00"
+    }
+  ]
+}
+```
+
+### comments.json
+
+```json
+{
+  "comments": [
+    {
+      "id": "uuid",
+      "album_id": "album-uuid",
+      "author": "Name",
+      "text": "Kommentar",
+      "created_at": "2024-12-27T14:30:00+01:00"
+    }
+  ]
+}
+```
+
+## Sicherheit
+
+- Admin-Passwort mit bcrypt gehasht
+- CSRF-Token für alle Admin-Aktionen
+- XSS-Schutz durch `htmlspecialchars()`
+- Rate-Limiting für Kommentare (5/Minute pro IP)
+- Honeypot-Feld gegen Spam-Bots
+- `.htaccess` schützt config.php und data/
+
+## Anforderungen
+
+- PHP 8.0+
+- Apache mit mod_rewrite (optional)
+- Schreibrechte für data/ und thumbnails/
+
+## Lizenz
+
+Privates Projekt für Familien-Nutzung.

familyalbums/admin.php

@@ -0,0 +1,658 @@
+<?php
+/**
+ * FamilyAlbums - Admin Interface
+ */
+
+require_once __DIR__ . '/config.php';
+session_start();
+
+$pageTitle = SITE_TITLE . ' - Administration';
+?>
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= e($pageTitle) ?></title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">
+    <style>
+        .tag-input { display: flex; flex-wrap: wrap; gap: 0.5rem; padding: 0.5rem; border: 1px solid #d1d5db; border-radius: 0.5rem; }
+        .tag-item { background: #dbeafe; color: #1d4ed8; padding: 0.25rem 0.5rem; border-radius: 9999px; display: flex; align-items: center; gap: 0.25rem; }
+        .tag-item button { color: #1d4ed8; cursor: pointer; }
+        .tag-input input { flex: 1; min-width: 100px; border: none; outline: none; }
+        .suggestions { position: absolute; top: 100%; left: 0; right: 0; background: white; border: 1px solid #d1d5db; border-radius: 0.5rem; max-height: 200px; overflow-y: auto; z-index: 10; }
+        .suggestions div { padding: 0.5rem 1rem; cursor: pointer; }
+        .suggestions div:hover { background: #f3f4f6; }
+    </style>
+</head>
+<body class="bg-gray-100 min-h-screen">
+    <!-- Login-Bereich (wird per JS gesteuert) -->
+    <div id="login-section" class="hidden min-h-screen flex items-center justify-center">
+        <div class="bg-white p-8 rounded-xl shadow-lg w-full max-w-md">
+            <h1 class="text-2xl font-bold text-center mb-6">
+                <i class="fas fa-lock mr-2 text-blue-600"></i>Admin Login
+            </h1>
+            <form id="login-form">
+                <div class="mb-4">
+                    <label class="block text-gray-700 mb-2">Passwort</label>
+                    <input type="password" id="login-password" required
+                           class="w-full px-4 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500"
+                           placeholder="Admin-Passwort eingeben">
+                </div>
+                <div id="login-error" class="hidden text-red-500 text-sm mb-4"></div>
+                <button type="submit" class="w-full bg-blue-600 text-white py-2 rounded-lg hover:bg-blue-700 transition">
+                    <i class="fas fa-sign-in-alt mr-2"></i>Anmelden
+                </button>
+            </form>
+            <p class="mt-4 text-center">
+                <a href="index.php" class="text-blue-600 hover:underline">
+                    <i class="fas fa-arrow-left mr-1"></i>Zurück zur Galerie
+                </a>
+            </p>
+        </div>
+    </div>
+
+    <!-- Admin-Bereich -->
+    <div id="admin-section" class="hidden">
+        <!-- Header -->
+        <header class="bg-gradient-to-r from-gray-800 to-gray-900 text-white shadow-lg">
+            <div class="container mx-auto px-4 py-4">
+                <div class="flex items-center justify-between">
+                    <h1 class="text-xl font-bold">
+                        <i class="fas fa-cog mr-2"></i><?= e($pageTitle) ?>
+                    </h1>
+                    <div class="flex items-center gap-4">
+                        <a href="index.php" class="text-white/80 hover:text-white">
+                            <i class="fas fa-eye mr-1"></i>Galerie
+                        </a>
+                        <button onclick="logout()" class="text-white/80 hover:text-white">
+                            <i class="fas fa-sign-out-alt mr-1"></i>Logout
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </header>
+
+        <!-- Tabs -->
+        <div class="bg-white shadow">
+            <div class="container mx-auto px-4">
+                <nav class="flex gap-4">
+                    <button onclick="showTab('albums')" id="tab-albums"
+                            class="tab-btn py-4 px-2 border-b-2 border-blue-600 text-blue-600 font-medium">
+                        <i class="fas fa-images mr-1"></i>Alben
+                    </button>
+                    <button onclick="showTab('comments')" id="tab-comments"
+                            class="tab-btn py-4 px-2 border-b-2 border-transparent text-gray-500 hover:text-gray-700">
+                        <i class="fas fa-comments mr-1"></i>Kommentare
+                    </button>
+                </nav>
+            </div>
+        </div>
+
+        <!-- Content -->
+        <main class="container mx-auto px-4 py-8">
+            <!-- Alben-Tab -->
+            <div id="content-albums">
+                <!-- Album hinzufügen -->
+                <div class="bg-white rounded-xl shadow-md p-6 mb-8">
+                    <h2 class="text-xl font-semibold mb-4">
+                        <i class="fas fa-plus-circle mr-2 text-green-600"></i>
+                        <span id="form-title">Neues Album hinzufügen</span>
+                    </h2>
+                    <form id="album-form" class="grid grid-cols-1 md:grid-cols-2 gap-4">
+                        <input type="hidden" id="album-id">
+
+                        <div>
+                            <label class="block text-gray-700 mb-1">Titel *</label>
+                            <input type="text" id="album-title" required
+                                   class="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500"
+                                   placeholder="z.B. Weihnachten bei Oma">
+                        </div>
+
+                        <div>
+                            <label class="block text-gray-700 mb-1">Datum *</label>
+                            <input type="date" id="album-date" required
+                                   class="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500">
+                        </div>
+
+                        <div class="md:col-span-2">
+                            <label class="block text-gray-700 mb-1">Nextcloud-Link *</label>
+                            <input type="url" id="album-url" required
+                                   class="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500"
+                                   placeholder="https://nextcloud.example.com/apps/photos/public/...">
+                        </div>
+
+                        <div class="md:col-span-2">
+                            <label class="block text-gray-700 mb-1">Beschreibung</label>
+                            <textarea id="album-description" rows="2"
+                                      class="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500"
+                                      placeholder="Kurze Beschreibung des Albums"></textarea>
+                        </div>
+
+                        <div class="md:col-span-2 relative">
+                            <label class="block text-gray-700 mb-1">Tags</label>
+                            <div class="tag-input" id="tags-container">
+                                <input type="text" id="tag-input" placeholder="Tag eingeben und Enter drücken">
+                            </div>
+                            <div id="tag-suggestions" class="suggestions hidden"></div>
+                            <input type="hidden" id="album-tags">
+                        </div>
+
+                        <div class="md:col-span-2">
+                            <label class="block text-gray-700 mb-1">Vorschaubild (optional)</label>
+                            <div class="flex gap-2">
+                                <input type="file" id="thumbnail-file" accept="image/*"
+                                       class="flex-1 px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500">
+                                <button type="button" onclick="uploadThumbnail()" class="px-4 py-2 bg-gray-200 rounded-lg hover:bg-gray-300">
+                                    <i class="fas fa-upload"></i>
+                                </button>
+                            </div>
+                            <input type="hidden" id="album-thumbnail">
+                            <div id="thumbnail-preview" class="mt-2"></div>
+                        </div>
+
+                        <div class="md:col-span-2 flex gap-2">
+                            <button type="submit" class="bg-green-600 text-white px-6 py-2 rounded-lg hover:bg-green-700 transition">
+                                <i class="fas fa-save mr-2"></i><span id="submit-text">Speichern</span>
+                            </button>
+                            <button type="button" onclick="resetForm()" class="bg-gray-200 px-6 py-2 rounded-lg hover:bg-gray-300 transition">
+                                <i class="fas fa-times mr-2"></i>Abbrechen
+                            </button>
+                        </div>
+                    </form>
+                </div>
+
+                <!-- Album-Liste -->
+                <div class="bg-white rounded-xl shadow-md p-6">
+                    <h2 class="text-xl font-semibold mb-4">
+                        <i class="fas fa-list mr-2 text-blue-600"></i>Alle Alben
+                    </h2>
+                    <div id="albums-list" class="overflow-x-auto">
+                        <table class="w-full">
+                            <thead class="bg-gray-50">
+                                <tr>
+                                    <th class="px-4 py-3 text-left text-gray-600">Titel</th>
+                                    <th class="px-4 py-3 text-left text-gray-600">Datum</th>
+                                    <th class="px-4 py-3 text-left text-gray-600">Tags</th>
+                                    <th class="px-4 py-3 text-right text-gray-600">Aktionen</th>
+                                </tr>
+                            </thead>
+                            <tbody id="albums-table-body">
+                                <!-- Wird per JS befüllt -->
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Kommentare-Tab -->
+            <div id="content-comments" class="hidden">
+                <div class="bg-white rounded-xl shadow-md p-6">
+                    <h2 class="text-xl font-semibold mb-4">
+                        <i class="fas fa-comments mr-2 text-blue-600"></i>Alle Kommentare
+                    </h2>
+                    <div id="comments-list" class="space-y-4">
+                        <!-- Wird per JS befüllt -->
+                    </div>
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <!-- Bestätigungs-Modal -->
+    <div id="confirm-modal" class="hidden fixed inset-0 bg-black/50 z-50 flex items-center justify-center p-4">
+        <div class="bg-white rounded-xl shadow-2xl max-w-md w-full p-6">
+            <h3 class="text-lg font-semibold mb-4" id="confirm-title">Bestätigung</h3>
+            <p id="confirm-message" class="text-gray-600 mb-6"></p>
+            <div class="flex justify-end gap-2">
+                <button onclick="closeConfirm()" class="px-4 py-2 bg-gray-200 rounded-lg hover:bg-gray-300">
+                    Abbrechen
+                </button>
+                <button id="confirm-btn" class="px-4 py-2 bg-red-600 text-white rounded-lg hover:bg-red-700">
+                    Löschen
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+    // === State ===
+    let csrfToken = '';
+    let allTags = [];
+    let currentTags = [];
+    let editingAlbumId = null;
+    let confirmCallback = null;
+
+    // === Auth ===
+    async function checkAuth() {
+        const response = await fetch('api.php?action=check_auth');
+        const data = await response.json();
+
+        if (data.authenticated) {
+            csrfToken = data.csrf;
+            document.getElementById('login-section').classList.add('hidden');
+            document.getElementById('admin-section').classList.remove('hidden');
+            loadAlbums();
+            loadAllTags();
+        } else {
+            document.getElementById('login-section').classList.remove('hidden');
+            document.getElementById('admin-section').classList.add('hidden');
+        }
+    }
+
+    document.getElementById('login-form').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        const password = document.getElementById('login-password').value;
+        const errorDiv = document.getElementById('login-error');
+
+        try {
+            const response = await fetch('api.php?action=login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ password })
+            });
+            const data = await response.json();
+
+            if (data.success) {
+                csrfToken = data.csrf;
+                document.getElementById('login-section').classList.add('hidden');
+                document.getElementById('admin-section').classList.remove('hidden');
+                loadAlbums();
+                loadAllTags();
+            } else {
+                errorDiv.textContent = data.error || 'Login fehlgeschlagen';
+                errorDiv.classList.remove('hidden');
+            }
+        } catch (err) {
+            errorDiv.textContent = 'Verbindungsfehler';
+            errorDiv.classList.remove('hidden');
+        }
+    });
+
+    async function logout() {
+        await fetch('api.php?action=logout', { method: 'POST' });
+        location.reload();
+    }
+
+    // === Tabs ===
+    function showTab(tab) {
+        document.querySelectorAll('.tab-btn').forEach(btn => {
+            btn.classList.remove('border-blue-600', 'text-blue-600');
+            btn.classList.add('border-transparent', 'text-gray-500');
+        });
+        document.getElementById(`tab-${tab}`).classList.add('border-blue-600', 'text-blue-600');
+        document.getElementById(`tab-${tab}`).classList.remove('border-transparent', 'text-gray-500');
+
+        document.getElementById('content-albums').classList.add('hidden');
+        document.getElementById('content-comments').classList.add('hidden');
+        document.getElementById(`content-${tab}`).classList.remove('hidden');
+
+        if (tab === 'comments') {
+            loadAllComments();
+        }
+    }
+
+    // === Albums ===
+    async function loadAlbums() {
+        const response = await fetch('api.php?action=albums');
+        const data = await response.json();
+        renderAlbumsTable(data.albums || []);
+    }
+
+    function renderAlbumsTable(albums) {
+        const tbody = document.getElementById('albums-table-body');
+
+        if (albums.length === 0) {
+            tbody.innerHTML = '<tr><td colspan="4" class="text-center py-8 text-gray-500">Noch keine Alben vorhanden</td></tr>';
+            return;
+        }
+
+        tbody.innerHTML = albums.map(album => `
+            <tr class="border-t hover:bg-gray-50">
+                <td class="px-4 py-3">
+                    <div class="font-medium">${escapeHtml(album.title)}</div>
+                    <div class="text-sm text-gray-500 truncate max-w-xs">${escapeHtml(album.url)}</div>
+                </td>
+                <td class="px-4 py-3 text-gray-600">${album.date}</td>
+                <td class="px-4 py-3">
+                    <div class="flex flex-wrap gap-1">
+                        ${album.tags.slice(0, 3).map(tag =>
+                            `<span class="bg-blue-100 text-blue-700 text-xs px-2 py-0.5 rounded-full">${escapeHtml(tag)}</span>`
+                        ).join('')}
+                        ${album.tags.length > 3 ? `<span class="text-gray-400 text-xs">+${album.tags.length - 3}</span>` : ''}
+                    </div>
+                </td>
+                <td class="px-4 py-3 text-right">
+                    <button onclick='editAlbum(${JSON.stringify(album).replace(/'/g, "&#39;")})' class="text-blue-600 hover:text-blue-800 mr-2">
+                        <i class="fas fa-edit"></i>
+                    </button>
+                    <button onclick="confirmDelete('album', '${album.id}', '${escapeHtml(album.title)}')" class="text-red-600 hover:text-red-800">
+                        <i class="fas fa-trash"></i>
+                    </button>
+                </td>
+            </tr>
+        `).join('');
+    }
+
+    async function loadAllTags() {
+        const response = await fetch('api.php?action=tags');
+        const data = await response.json();
+        allTags = data.tags || [];
+    }
+
+    // === Album Form ===
+    document.getElementById('album-form').addEventListener('submit', async (e) => {
+        e.preventDefault();
+
+        const album = {
+            csrf: csrfToken,
+            title: document.getElementById('album-title').value,
+            url: document.getElementById('album-url').value,
+            date: document.getElementById('album-date').value,
+            description: document.getElementById('album-description').value,
+            tags: currentTags,
+            thumbnail: document.getElementById('album-thumbnail').value
+        };
+
+        let url = 'api.php?action=album';
+        let method = 'POST';
+
+        if (editingAlbumId) {
+            album.id = editingAlbumId;
+            method = 'PUT';
+        }
+
+        try {
+            const response = await fetch(url, {
+                method: method,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(album)
+            });
+            const data = await response.json();
+
+            if (data.success) {
+                resetForm();
+                loadAlbums();
+                loadAllTags();
+            } else {
+                alert(data.error || 'Fehler beim Speichern');
+            }
+        } catch (err) {
+            alert('Verbindungsfehler');
+        }
+    });
+
+    function editAlbum(album) {
+        editingAlbumId = album.id;
+        document.getElementById('album-id').value = album.id;
+        document.getElementById('album-title').value = album.title;
+        document.getElementById('album-url').value = album.url;
+        document.getElementById('album-date').value = album.date;
+        document.getElementById('album-description').value = album.description || '';
+        document.getElementById('album-thumbnail').value = album.thumbnail || '';
+
+        // Tags
+        currentTags = [...album.tags];
+        renderTags();
+
+        // Thumbnail preview
+        if (album.thumbnail) {
+            document.getElementById('thumbnail-preview').innerHTML =
+                `<img src="${escapeHtml(album.thumbnail)}" class="h-20 rounded">`;
+        }
+
+        document.getElementById('form-title').textContent = 'Album bearbeiten';
+        document.getElementById('submit-text').textContent = 'Aktualisieren';
+
+        // Scroll to form
+        document.getElementById('album-form').scrollIntoView({ behavior: 'smooth' });
+    }
+
+    function resetForm() {
+        editingAlbumId = null;
+        document.getElementById('album-form').reset();
+        document.getElementById('album-thumbnail').value = '';
+        document.getElementById('thumbnail-preview').innerHTML = '';
+        currentTags = [];
+        renderTags();
+        document.getElementById('form-title').textContent = 'Neues Album hinzufügen';
+        document.getElementById('submit-text').textContent = 'Speichern';
+    }
+
+    async function deleteAlbum(id) {
+        try {
+            const response = await fetch('api.php?action=album', {
+                method: 'DELETE',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ id, csrf: csrfToken })
+            });
+            const data = await response.json();
+
+            if (data.success) {
+                loadAlbums();
+            } else {
+                alert(data.error || 'Fehler beim Löschen');
+            }
+        } catch (err) {
+            alert('Verbindungsfehler');
+        }
+    }
+
+    // === Tags ===
+    function renderTags() {
+        const container = document.getElementById('tags-container');
+        const input = document.getElementById('tag-input');
+
+        // Remove existing tag items
+        container.querySelectorAll('.tag-item').forEach(el => el.remove());
+
+        // Add tag items before input
+        currentTags.forEach((tag, index) => {
+            const span = document.createElement('span');
+            span.className = 'tag-item';
+            span.innerHTML = `${escapeHtml(tag)}<button type="button" onclick="removeTag(${index})">&times;</button>`;
+            container.insertBefore(span, input);
+        });
+    }
+
+    function removeTag(index) {
+        currentTags.splice(index, 1);
+        renderTags();
+    }
+
+    document.getElementById('tag-input').addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' || e.key === ',') {
+            e.preventDefault();
+            const value = e.target.value.trim();
+            if (value && !currentTags.includes(value)) {
+                currentTags.push(value);
+                renderTags();
+            }
+            e.target.value = '';
+            document.getElementById('tag-suggestions').classList.add('hidden');
+        }
+    });
+
+    document.getElementById('tag-input').addEventListener('input', (e) => {
+        const value = e.target.value.toLowerCase();
+        const suggestions = document.getElementById('tag-suggestions');
+
+        if (value.length < 1) {
+            suggestions.classList.add('hidden');
+            return;
+        }
+
+        const matches = allTags.filter(tag =>
+            tag.toLowerCase().includes(value) && !currentTags.includes(tag)
+        ).slice(0, 5);
+
+        if (matches.length === 0) {
+            suggestions.classList.add('hidden');
+            return;
+        }
+
+        suggestions.innerHTML = matches.map(tag =>
+            `<div onclick="selectTag('${escapeHtml(tag)}')">${escapeHtml(tag)}</div>`
+        ).join('');
+        suggestions.classList.remove('hidden');
+    });
+
+    function selectTag(tag) {
+        if (!currentTags.includes(tag)) {
+            currentTags.push(tag);
+            renderTags();
+        }
+        document.getElementById('tag-input').value = '';
+        document.getElementById('tag-suggestions').classList.add('hidden');
+    }
+
+    // === Thumbnail Upload ===
+    async function uploadThumbnail() {
+        const fileInput = document.getElementById('thumbnail-file');
+        if (!fileInput.files[0]) {
+            alert('Bitte wähle zuerst ein Bild aus');
+            return;
+        }
+
+        const formData = new FormData();
+        formData.append('thumbnail', fileInput.files[0]);
+        formData.append('csrf', csrfToken);
+
+        try {
+            const response = await fetch('api.php?action=upload_thumbnail', {
+                method: 'POST',
+                body: formData
+            });
+            const data = await response.json();
+
+            if (data.success) {
+                document.getElementById('album-thumbnail').value = data.path;
+                document.getElementById('thumbnail-preview').innerHTML =
+                    `<img src="${escapeHtml(data.path)}" class="h-20 rounded">`;
+                fileInput.value = '';
+            } else {
+                alert(data.error || 'Upload fehlgeschlagen');
+            }
+        } catch (err) {
+            alert('Verbindungsfehler');
+        }
+    }
+
+    // === Comments ===
+    async function loadAllComments() {
+        const albumsResponse = await fetch('api.php?action=albums');
+        const albumsData = await albumsResponse.json();
+        const albums = albumsData.albums || [];
+
+        const commentsContainer = document.getElementById('comments-list');
+        commentsContainer.innerHTML = '<p class="text-center"><i class="fas fa-spinner fa-spin"></i> Lade Kommentare...</p>';
+
+        // Kommentare für alle Alben laden
+        const allComments = [];
+        for (const album of albums) {
+            const response = await fetch(`api.php?action=comments&album_id=${album.id}`);
+            const data = await response.json();
+            (data.comments || []).forEach(comment => {
+                comment.albumTitle = album.title;
+                allComments.push(comment);
+            });
+        }
+
+        // Nach Datum sortieren
+        allComments.sort((a, b) => b.created_at.localeCompare(a.created_at));
+
+        if (allComments.length === 0) {
+            commentsContainer.innerHTML = '<p class="text-center text-gray-500 py-8">Noch keine Kommentare vorhanden</p>';
+            return;
+        }
+
+        commentsContainer.innerHTML = allComments.map(comment => `
+            <div class="bg-gray-50 p-4 rounded-lg">
+                <div class="flex justify-between items-start mb-2">
+                    <div>
+                        <span class="font-semibold">${escapeHtml(comment.author)}</span>
+                        <span class="text-gray-400 text-sm ml-2">${formatDateTime(comment.created_at)}</span>
+                    </div>
+                    <button onclick="confirmDelete('comment', '${comment.id}', 'diesen Kommentar')" class="text-red-600 hover:text-red-800">
+                        <i class="fas fa-trash"></i>
+                    </button>
+                </div>
+                <p class="text-gray-700 mb-2">${escapeHtml(comment.text)}</p>
+                <p class="text-sm text-gray-500">
+                    <i class="fas fa-images mr-1"></i>${escapeHtml(comment.albumTitle)}
+                </p>
+            </div>
+        `).join('');
+    }
+
+    async function deleteComment(id) {
+        try {
+            const response = await fetch('api.php?action=comment', {
+                method: 'DELETE',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ id, csrf: csrfToken })
+            });
+            const data = await response.json();
+
+            if (data.success) {
+                loadAllComments();
+            } else {
+                alert(data.error || 'Fehler beim Löschen');
+            }
+        } catch (err) {
+            alert('Verbindungsfehler');
+        }
+    }
+
+    // === Confirm Modal ===
+    function confirmDelete(type, id, name) {
+        document.getElementById('confirm-message').textContent =
+            `Möchtest du "${name}" wirklich löschen?`;
+
+        confirmCallback = () => {
+            if (type === 'album') {
+                deleteAlbum(id);
+            } else if (type === 'comment') {
+                deleteComment(id);
+            }
+        };
+
+        document.getElementById('confirm-modal').classList.remove('hidden');
+    }
+
+    function closeConfirm() {
+        document.getElementById('confirm-modal').classList.add('hidden');
+        confirmCallback = null;
+    }
+
+    document.getElementById('confirm-btn').addEventListener('click', () => {
+        if (confirmCallback) {
+            confirmCallback();
+        }
+        closeConfirm();
+    });
+
+    // === Helpers ===
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    function formatDateTime(isoStr) {
+        const date = new Date(isoStr);
+        return date.toLocaleDateString('de-CH', {
+            day: 'numeric',
+            month: 'long',
+            year: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit'
+        });
+    }
+
+    // === Init ===
+    checkAuth();
+    </script>
+</body>
+</html>

familyalbums/api.php

@@ -0,0 +1,350 @@
+<?php
+/**
+ * FamilyAlbums - API Endpunkte
+ */
+
+require_once __DIR__ . '/config.php';
+
+session_start();
+
+header('Content-Type: application/json; charset=utf-8');
+
+$method = $_SERVER['REQUEST_METHOD'];
+$action = $_GET['action'] ?? '';
+
+// Hilfsfunktion: JSON Response
+function json_response(array $data, int $code = 200): void {
+    http_response_code($code);
+    echo json_encode($data, JSON_UNESCAPED_UNICODE);
+    exit;
+}
+
+// Hilfsfunktion: Admin-Check
+function require_admin(): void {
+    if (empty($_SESSION['admin_logged_in'])) {
+        json_response(['error' => 'Nicht autorisiert'], 401);
+    }
+}
+
+// === ALBEN ===
+
+if ($action === 'albums' && $method === 'GET') {
+    // Alle Alben abrufen (öffentlich)
+    $data = read_json(ALBUMS_FILE);
+    $albums = $data['albums'] ?? [];
+
+    // Filter: Jahr
+    if (!empty($_GET['year'])) {
+        $year = $_GET['year'];
+        $albums = array_filter($albums, fn($a) => substr($a['date'], 0, 4) === $year);
+    }
+
+    // Filter: Monat
+    if (!empty($_GET['month'])) {
+        $month = $_GET['month'];
+        $albums = array_filter($albums, fn($a) => substr($a['date'], 5, 2) === $month);
+    }
+
+    // Filter: Suche
+    if (!empty($_GET['search'])) {
+        $search = mb_strtolower($_GET['search']);
+        $albums = array_filter($albums, function($a) use ($search) {
+            $haystack = mb_strtolower($a['title'] . ' ' . $a['description'] . ' ' . implode(' ', $a['tags']));
+            return str_contains($haystack, $search);
+        });
+    }
+
+    // Sortierung
+    $sort = $_GET['sort'] ?? 'newest';
+    usort($albums, function($a, $b) use ($sort) {
+        if ($sort === 'oldest') {
+            return strcmp($a['date'], $b['date']);
+        }
+        return strcmp($b['date'], $a['date']); // newest first
+    });
+
+    json_response(['albums' => array_values($albums)]);
+}
+
+if ($action === 'album' && $method === 'POST') {
+    // Album erstellen (Admin)
+    require_admin();
+
+    $input = json_decode(file_get_contents('php://input'), true);
+
+    if (!csrf_validate($input['csrf'] ?? '')) {
+        json_response(['error' => 'Ungültiges CSRF-Token'], 403);
+    }
+
+    if (empty($input['title']) || empty($input['url']) || empty($input['date'])) {
+        json_response(['error' => 'Titel, URL und Datum sind Pflichtfelder'], 400);
+    }
+
+    $album = [
+        'id' => generate_uuid(),
+        'title' => trim($input['title']),
+        'url' => trim($input['url']),
+        'date' => $input['date'],
+        'tags' => array_map('trim', $input['tags'] ?? []),
+        'description' => trim($input['description'] ?? ''),
+        'thumbnail' => $input['thumbnail'] ?? '',
+        'created_at' => date('c')
+    ];
+
+    $data = read_json(ALBUMS_FILE);
+    $data['albums'][] = $album;
+    write_json(ALBUMS_FILE, $data);
+
+    json_response(['success' => true, 'album' => $album]);
+}
+
+if ($action === 'album' && $method === 'PUT') {
+    // Album bearbeiten (Admin)
+    require_admin();
+
+    $input = json_decode(file_get_contents('php://input'), true);
+
+    if (!csrf_validate($input['csrf'] ?? '')) {
+        json_response(['error' => 'Ungültiges CSRF-Token'], 403);
+    }
+
+    $id = $input['id'] ?? '';
+
+    $data = read_json(ALBUMS_FILE);
+    $found = false;
+
+    foreach ($data['albums'] as &$album) {
+        if ($album['id'] === $id) {
+            $album['title'] = trim($input['title'] ?? $album['title']);
+            $album['url'] = trim($input['url'] ?? $album['url']);
+            $album['date'] = $input['date'] ?? $album['date'];
+            $album['tags'] = array_map('trim', $input['tags'] ?? $album['tags']);
+            $album['description'] = trim($input['description'] ?? $album['description']);
+            $album['thumbnail'] = $input['thumbnail'] ?? $album['thumbnail'];
+            $found = true;
+            break;
+        }
+    }
+
+    if (!$found) {
+        json_response(['error' => 'Album nicht gefunden'], 404);
+    }
+
+    write_json(ALBUMS_FILE, $data);
+    json_response(['success' => true]);
+}
+
+if ($action === 'album' && $method === 'DELETE') {
+    // Album löschen (Admin)
+    require_admin();
+
+    $input = json_decode(file_get_contents('php://input'), true);
+
+    if (!csrf_validate($input['csrf'] ?? '')) {
+        json_response(['error' => 'Ungültiges CSRF-Token'], 403);
+    }
+
+    $id = $input['id'] ?? '';
+
+    $data = read_json(ALBUMS_FILE);
+    $data['albums'] = array_filter($data['albums'], fn($a) => $a['id'] !== $id);
+    $data['albums'] = array_values($data['albums']);
+    write_json(ALBUMS_FILE, $data);
+
+    // Zugehörige Kommentare löschen
+    $comments = read_json(COMMENTS_FILE);
+    $comments['comments'] = array_filter($comments['comments'], fn($c) => $c['album_id'] !== $id);
+    $comments['comments'] = array_values($comments['comments']);
+    write_json(COMMENTS_FILE, $comments);
+
+    json_response(['success' => true]);
+}
+
+// === KOMMENTARE ===
+
+if ($action === 'comments' && $method === 'GET') {
+    // Kommentare für Album abrufen (öffentlich)
+    $album_id = $_GET['album_id'] ?? '';
+
+    $data = read_json(COMMENTS_FILE);
+    $comments = array_filter($data['comments'] ?? [], fn($c) => $c['album_id'] === $album_id);
+
+    // Nach Datum sortieren (neueste zuerst)
+    usort($comments, fn($a, $b) => strcmp($b['created_at'], $a['created_at']));
+
+    json_response(['comments' => array_values($comments)]);
+}
+
+if ($action === 'comment' && $method === 'POST') {
+    // Kommentar erstellen (öffentlich)
+    $input = json_decode(file_get_contents('php://input'), true);
+
+    if (empty($input['album_id']) || empty($input['author']) || empty($input['text'])) {
+        json_response(['error' => 'Album-ID, Name und Text sind Pflichtfelder'], 400);
+    }
+
+    // Honeypot-Check (Spam-Schutz)
+    if (!empty($input['website'])) {
+        json_response(['success' => true]); // Fake-Erfolg für Bots
+    }
+
+    // Rate-Limiting: Max 5 Kommentare pro Minute pro IP
+    $ip = $_SERVER['REMOTE_ADDR'];
+    $rate_file = DATA_PATH . 'rate_' . md5($ip) . '.json';
+    $rate_data = read_json($rate_file);
+    $now = time();
+    $rate_data['times'] = array_filter($rate_data['times'] ?? [], fn($t) => $t > $now - 60);
+
+    if (count($rate_data['times']) >= 5) {
+        json_response(['error' => 'Zu viele Kommentare. Bitte warte eine Minute.'], 429);
+    }
+
+    $rate_data['times'][] = $now;
+    write_json($rate_file, $rate_data);
+
+    $comment = [
+        'id' => generate_uuid(),
+        'album_id' => $input['album_id'],
+        'author' => trim($input['author']),
+        'text' => trim($input['text']),
+        'created_at' => date('c')
+    ];
+
+    $data = read_json(COMMENTS_FILE);
+    $data['comments'][] = $comment;
+    write_json(COMMENTS_FILE, $data);
+
+    json_response(['success' => true, 'comment' => $comment]);
+}
+
+if ($action === 'comment' && $method === 'DELETE') {
+    // Kommentar löschen (Admin)
+    require_admin();
+
+    $input = json_decode(file_get_contents('php://input'), true);
+
+    if (!csrf_validate($input['csrf'] ?? '')) {
+        json_response(['error' => 'Ungültiges CSRF-Token'], 403);
+    }
+
+    $id = $input['id'] ?? '';
+
+    $data = read_json(COMMENTS_FILE);
+    $data['comments'] = array_filter($data['comments'], fn($c) => $c['id'] !== $id);
+    $data['comments'] = array_values($data['comments']);
+    write_json(COMMENTS_FILE, $data);
+
+    json_response(['success' => true]);
+}
+
+// === TAGS ===
+
+if ($action === 'tags' && $method === 'GET') {
+    // Alle verwendeten Tags abrufen (für Vorschläge)
+    $data = read_json(ALBUMS_FILE);
+    $tags = [];
+
+    foreach ($data['albums'] ?? [] as $album) {
+        foreach ($album['tags'] ?? [] as $tag) {
+            $tags[$tag] = ($tags[$tag] ?? 0) + 1;
+        }
+    }
+
+    arsort($tags);
+    json_response(['tags' => array_keys($tags)]);
+}
+
+// === JAHRE/MONATE ===
+
+if ($action === 'dates' && $method === 'GET') {
+    // Verfügbare Jahre und Monate
+    $data = read_json(ALBUMS_FILE);
+    $years = [];
+
+    foreach ($data['albums'] ?? [] as $album) {
+        $year = substr($album['date'], 0, 4);
+        $month = substr($album['date'], 5, 2);
+
+        if (!isset($years[$year])) {
+            $years[$year] = [];
+        }
+        if (!in_array($month, $years[$year])) {
+            $years[$year][] = $month;
+        }
+    }
+
+    // Sortieren
+    krsort($years);
+    foreach ($years as &$months) {
+        sort($months);
+    }
+
+    json_response(['dates' => $years]);
+}
+
+// === AUTH ===
+
+if ($action === 'login' && $method === 'POST') {
+    $input = json_decode(file_get_contents('php://input'), true);
+    $password = $input['password'] ?? '';
+
+    if (password_verify($password, ADMIN_PASSWORD_HASH)) {
+        $_SESSION['admin_logged_in'] = true;
+        $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
+        json_response(['success' => true, 'csrf' => $_SESSION['csrf_token']]);
+    }
+
+    // Verzögerung gegen Brute-Force
+    sleep(1);
+    json_response(['error' => 'Falsches Passwort'], 401);
+}
+
+if ($action === 'logout' && $method === 'POST') {
+    session_destroy();
+    json_response(['success' => true]);
+}
+
+if ($action === 'check_auth' && $method === 'GET') {
+    json_response([
+        'authenticated' => !empty($_SESSION['admin_logged_in']),
+        'csrf' => $_SESSION['csrf_token'] ?? ''
+    ]);
+}
+
+// === THUMBNAIL UPLOAD ===
+
+if ($action === 'upload_thumbnail' && $method === 'POST') {
+    require_admin();
+
+    if (empty($_POST['csrf']) || !csrf_validate($_POST['csrf'])) {
+        json_response(['error' => 'Ungültiges CSRF-Token'], 403);
+    }
+
+    if (empty($_FILES['thumbnail']) || $_FILES['thumbnail']['error'] !== UPLOAD_ERR_OK) {
+        json_response(['error' => 'Kein Bild hochgeladen'], 400);
+    }
+
+    $file = $_FILES['thumbnail'];
+    $allowed = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
+
+    if (!in_array($file['type'], $allowed)) {
+        json_response(['error' => 'Nur JPG, PNG, GIF und WebP erlaubt'], 400);
+    }
+
+    if ($file['size'] > 5 * 1024 * 1024) {
+        json_response(['error' => 'Maximale Dateigrösse: 5MB'], 400);
+    }
+
+    $ext = pathinfo($file['name'], PATHINFO_EXTENSION);
+    $filename = generate_uuid() . '.' . $ext;
+    $path = THUMBNAIL_PATH . $filename;
+
+    if (!move_uploaded_file($file['tmp_name'], $path)) {
+        json_response(['error' => 'Upload fehlgeschlagen'], 500);
+    }
+
+    json_response(['success' => true, 'path' => THUMBNAIL_URL . $filename]);
+}
+
+// Unbekannte Aktion
+json_response(['error' => 'Unbekannte Aktion'], 404);

familyalbums/config.php

@@ -0,0 +1,91 @@
+<?php
+/**
+ * FamilyAlbums - Konfiguration
+ *
+ * WICHTIG: Nach erster Installation Passwort ändern!
+ * Neuen Hash generieren: php -r "echo password_hash('deinPasswort', PASSWORD_DEFAULT);"
+ */
+
+// Standard-Passwort: "familie2024" - BITTE ÄNDERN!
+define('ADMIN_PASSWORD_HASH', '$2y$10$YxQx8B7GkDqNmPrC4VzKH.qN4tQ8WvX5kF7mZ3hJ9aE1bC2dR6uYO');
+
+define('SITE_TITLE', 'Familien-Fotoalben');
+define('DATA_PATH', __DIR__ . '/data/');
+define('THUMBNAIL_PATH', __DIR__ . '/thumbnails/');
+define('THUMBNAIL_URL', 'thumbnails/');
+
+define('ALBUMS_FILE', DATA_PATH . 'albums.json');
+define('COMMENTS_FILE', DATA_PATH . 'comments.json');
+
+// Session-Einstellungen
+define('SESSION_LIFETIME', 3600); // 1 Stunde
+
+// Zeitzone
+date_default_timezone_set('Europe/Zurich');
+
+/**
+ * JSON-Datei lesen
+ */
+function read_json(string $file): array {
+    if (!file_exists($file)) {
+        return [];
+    }
+    $content = file_get_contents($file);
+    return json_decode($content, true) ?? [];
+}
+
+/**
+ * JSON-Datei schreiben
+ */
+function write_json(string $file, array $data): bool {
+    $dir = dirname($file);
+    if (!is_dir($dir)) {
+        mkdir($dir, 0770, true);
+    }
+    return file_put_contents($file, json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)) !== false;
+}
+
+/**
+ * UUID generieren
+ */
+function generate_uuid(): string {
+    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
+        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
+        mt_rand(0, 0xffff),
+        mt_rand(0, 0x0fff) | 0x4000,
+        mt_rand(0, 0x3fff) | 0x8000,
+        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
+    );
+}
+
+/**
+ * XSS-sichere Ausgabe
+ */
+function e(string $str): string {
+    return htmlspecialchars($str, ENT_QUOTES, 'UTF-8');
+}
+
+/**
+ * CSRF-Token generieren
+ */
+function csrf_token(): string {
+    if (empty($_SESSION['csrf_token'])) {
+        $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
+    }
+    return $_SESSION['csrf_token'];
+}
+
+/**
+ * CSRF-Token validieren
+ */
+function csrf_validate(string $token): bool {
+    return isset($_SESSION['csrf_token']) && hash_equals($_SESSION['csrf_token'], $token);
+}
+
+// Initialisiere Daten-Dateien falls nicht vorhanden
+if (!file_exists(ALBUMS_FILE)) {
+    write_json(ALBUMS_FILE, ['albums' => []]);
+}
+if (!file_exists(COMMENTS_FILE)) {
+    write_json(COMMENTS_FILE, ['comments' => []]);
+}

familyalbums/data/.htaccess

@@ -0,0 +1,8 @@
+# Deny access to all files in this directory
+<IfModule mod_authz_core.c>
+    Require all denied
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Order deny,allow
+    Deny from all
+</IfModule>

familyalbums/data/albums.json

@@ -0,0 +1,14 @@
+{
+    "albums": [
+        {
+            "id": "demo-001",
+            "title": "Weihnachten 2024",
+            "url": "https://nextcloud.example.com/apps/photos/public/demo",
+            "date": "2024-12-25",
+            "tags": ["weihnachten", "familie", "2024"],
+            "description": "Bescherung und Festessen bei der Familie",
+            "thumbnail": "",
+            "created_at": "2024-12-26T10:00:00+01:00"
+        }
+    ]
+}

familyalbums/data/comments.json

@@ -0,0 +1,3 @@
+{
+    "comments": []
+}