mana-swift-llm/Sources/ManaLLM/LLMRouter.swift

import Foundation
import OSLog

/// Zentrale Drehscheibe: hält alle LLM-Backends, wählt nach App-
/// Preference + Availability das passende und liefert eine
/// einheitliche `generate`/`summarize`-API.
///
/// **Routing-Logik in `currentBackend()`:**
///
///   1. App übergibt eine Priority-Liste (`preferredBackends`) — z.B.
///      `[.appleFM, .gemmaE2B, .noOp]`.
///   2. Router fragt jedes Backend nach `availability()` und nimmt
///      das erste mit `.isSelectable`-Status (verfügbar oder lokal
///      gecacht).
///   3. Bei nichts verfügbar → `NoOpBackend`. UI rendert
///      `availabilityMap()` separat, damit der User weiß warum.
///
/// Apps können das auch komplett umgehen und ein Backend direkt
/// instanziieren — z.B. `await AppleFMBackend().generate(...)`.
public actor LLMRouter {
	/// Bequemer App-übergreifender Default mit allen vier Backends.
	/// Apps mit weniger Backends überschreiben das.
	public static let shared = LLMRouter()

	private let appleFM = AppleFMBackend()
	private let noOp = NoOpBackend()
	private let gemmaE2B = GemmaBackend(variant: .e2b)
	private let gemmaE4B = GemmaBackend(variant: .e4b)

	/// Priority-Reihenfolge der Backends. Apps können das je nach
	/// Use-Case justieren — z.B. moodlit will Gemma E2B bevor es FM
	/// (Creative-Mapping), pageta will FM zuerst (Summary).
	private var preferred: [LLMBackendID]

	public init(preferred: [LLMBackendID] = [.appleFM, .gemmaE2B, .gemmaE4B, .noOp]) {
		self.preferred = preferred
	}

	public func setPreferred(_ ids: [LLMBackendID]) {
		preferred = ids
	}

	public func backend(for id: LLMBackendID) -> LLMBackend {
		switch id {
		case .noOp: noOp
		case .appleFM: appleFM
		case .gemmaE2B: gemmaE2B
		case .gemmaE4B: gemmaE4B
		}
	}

	/// Wählt das erste verfügbare Backend aus der Preference-Liste.
	/// Bevorzugt strikt `.available` (Modell bereit). Wenn kein
	/// `.available` gefunden → fällt auf `.requiresDownload`-Fall
	/// zurück, falls in der Liste. Letzte Notbremse: NoOp.
	public func currentBackend() async -> LLMBackend {
		// Erster Pass: `.available` only.
		for id in preferred {
			let candidate = backend(for: id)
			if await candidate.availability() == .available {
				return candidate
			}
		}
		// Zweiter Pass: irgendwas selectable (auch requires-Download).
		for id in preferred {
			let candidate = backend(for: id)
			let avail = await candidate.availability()
			if avail.isSelectable {
				LLMLog.router.notice(
					"Router: kein .available — pick \(id.rawValue, privacy: .public) (\(String(describing: avail), privacy: .public))"
				)
				return candidate
			}
		}
		LLMLog.router.notice("Router: keine verfügbaren Backends — NoOp")
		return noOp
	}

	// MARK: - Convenience

	public func generate(
		prompt: String,
		instructions: String? = nil,
		maxTokens: Int = 500
	) async -> String? {
		let backend = await currentBackend()
		return await backend.generate(
			prompt: prompt,
			instructions: instructions,
			maxTokens: maxTokens
		)
	}

	public func summarize(transcript: String) async -> LLMSummary? {
		let backend = await currentBackend()
		return await backend.summarize(transcript: transcript)
	}

	/// UI-helper: pro Backend-ID den Availability-Status, etwa für die
	/// Settings-Liste. Parallelisiert über die Backends.
	public func availabilityMap() async -> [LLMBackendID: LLMAvailability] {
		var result: [LLMBackendID: LLMAvailability] = [:]
		for id in LLMBackendID.allCases {
			result[id] = await backend(for: id).availability()
		}
		return result
	}
}