Kotlin et Android

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        mavenCentral()
        mavenLocal() // tant que le SDK n'est publié que localement (./gradlew publishToMavenLocal)
    }
}

// build.gradle.kts du module
dependencies {
    implementation("ch.valais-connect:gaspard:1.1.0")
}

val gaspard = GaspardClient {
    apiKey = "vck_live_…"            // OU publishableKey = "vcp_live_…" (exactement une des deux)
    baseUrl = "https://hubmix.dealmood-solutions.com" // par défaut ; le SDK ajoute /v1/public
    maxRetries = 2                   // par défaut ; 0 désactive les nouvelles tentatives
    timeout = 60.seconds             // par requête ; un flux n'a pas de délai total
    // okHttpClient = monOkHttp      // pour partager connexions, intercepteurs, proxy…
}

val debut: Instant = conversation.startedAt.toGaspardInstant()

// Un seul client pour toute l'application (p. ex. dans votre conteneur d'injection).
val gaspard = GaspardClient {
    publishableKey = BuildConfig.GASPARD_PUBLISHABLE_KEY // vcp_live_…
    origin = "https://app.mon-domaine.ch"
}

private val Context.gaspardStore by preferencesDataStore(name = "gaspard")
private val VISITOR_TOKEN = stringPreferencesKey("visitor_token")

data class ChatUiState(
    val notice: PrivacyNotice? = null,      // non null : afficher le dialogue de consentement
    val answer: String = "",
    val sources: List<Source> = emptyList(),
    val loading: Boolean = false,
    val error: String? = null,
)

class ChatViewModel(
    private val gaspard: GaspardClient,
    private val store: DataStore<Preferences>,
) : ViewModel() {
    private val _state = MutableStateFlow(ChatUiState())
    val state: StateFlow<ChatUiState> = _state.asStateFlow()
    private var conversationId: String? = null
    private var asking: Job? = null

    init {
        viewModelScope.launch {
            val saved = store.data.first()[VISITOR_TOKEN]
            if (saved != null) {
                gaspard.setVisitorToken(saved)
            } else {
                // Pas encore de session : montrer la notice avant tout.
                _state.update { it.copy(notice = gaspard.privacyNotice(locale = "fr")) }
            }
        }
    }

    /** Appelé par le bouton « J'accepte » du dialogue. */
    fun acceptNotice(allowTraining: Boolean) = viewModelScope.launch {
        try {
            val session = gaspard.openSession(consent = true, locale = "fr", allowTraining = allowTraining)
            store.edit { it[VISITOR_TOKEN] = session.token }
            _state.update { it.copy(notice = null) }
        } catch (e: GaspardException) {
            _state.update { it.copy(error = e.message) }
        }
    }

    fun ask(question: String) {
        asking?.cancel() // une nouvelle question annule la précédente (et son appel HTTP)
        asking = viewModelScope.launch {
            _state.update { it.copy(answer = "", sources = emptyList(), loading = true, error = null) }
            try {
                val id = conversationId ?: gaspard.startConversation(locale = "fr", page = "accueil").id
                    .also { conversationId = it }
                gaspard.askStream(id, question).collect { event ->
                    when (event) {
                        is GaspardStreamEvent.Delta ->
                            _state.update { it.copy(answer = it.answer + event.text) }
                        is GaspardStreamEvent.Completed ->
                            _state.update { it.copy(answer = event.answer.text, sources = event.answer.sources) }
                    }
                }
            } catch (e: GaspardException) {
                when (e.code) {
                    "session_required" -> { // jeton expiré ou effacé : redemander le consentement
                        gaspard.setVisitorToken(null)
                        store.edit { it.remove(VISITOR_TOKEN) }
                        _state.update { it.copy(notice = gaspard.privacyNotice()) }
                    }
                    "conversation_full" -> conversationId = null // la prochaine question en ouvre une autre
                    else -> _state.update { it.copy(error = "Gaspard est indisponible, réessayez.") }
                }
            } finally {
                _state.update { it.copy(loading = false) }
            }
        }
    }
}

val gaspard = GaspardClient {
    apiKey = System.getenv("GASPARD_API_KEY") // vck_live_…, jamais côté client
}

fun Application.gaspardRoutes() = routing {
    post("/assistant/{conversationId}") {
        val user = call.principal<UserIdPrincipal>()!!.name
        val question = call.receiveText()
        // Une conversation par utilisateur de votre service : X-End-User
        val answer = gaspard.forEndUser(user).ask(call.parameters["conversationId"]!!, question)
        call.respond(mapOf("text" to answer.text, "sources" to answer.sources.map { it.name }))
    }
}

@Configuration
class GaspardConfiguration {
    @Bean
    fun gaspard(@Value("\${gaspard.api-key}") apiKey: String): GaspardClient =
        GaspardClient { this.apiKey = apiKey }
}

@RestController
class AssistantController(private val gaspard: GaspardClient) {
    @PostMapping("/assistant/conversations")
    suspend fun start(principal: Principal): Conversation =
        gaspard.forEndUser(principal.name).startConversation(locale = "fr")

    @GetMapping("/assistant/knowledge")
    suspend fun search(@RequestParam q: String): List<Passage> =
        gaspard.searchKnowledge(q, limit = 5).passages
}

val result = gaspard.trust.assess(
    listOf(TrustListing(kind = "housing", title = annonce.titre, description = annonce.texte,
        priceAmount = annonce.loyer, currency = "EUR", countryCode = "FR", city = "Lyon")),
)
if (result.assessments.first().withheld) { /* à faire vérifier ; findings dit pourquoi */ }

val cartes = gaspard.tutor.flashcards(Lesson(title = "La photosynthèse", content = texte), count = 8)
val vecteurs = gaspard.embeddings.create(listOf("chambre à louer", "room for rent")).embeddings

post("/webhooks/valais-connect") {   // Ktor
    val body = call.receive<ByteArray>()
    try {
        val event = GaspardWebhooks.verify(body, call.request.headers["X-VC-Signature"], listOf(secret))
        // dédoublonner sur event.id, puis traiter event.type (key.revoked, quota.warning…)
        call.respond(HttpStatusCode.NoContent)
    } catch (e: WebhookVerificationException) {
        call.respond(HttpStatusCode.BadRequest, e.code)
    }
}

gaspard.askStream(conversationId, "Wo finde ich einen Studentenjob in Berlin?").collect { event ->
    when (event) {
        is GaspardStreamEvent.Delta -> print(event.text)
        is GaspardStreamEvent.Completed -> println("\nSources : ${event.answer.sources}")
    }
}

try {
    gaspard.ask(conversationId, question)
} catch (e: GaspardException) {
    when (e.code) {
        "rate_limited", "assistant_busy" -> afficher("Réessayez dans ${e.retryAfterSeconds ?: 5} s")
        "token_quota_exceeded" -> afficher("Quota du mois atteint")
        else -> log.warn("Gaspard ${e.status} ${e.code} (requête ${e.requestId})", e)
    }
}