dependencies {
    val twitchKtVersion = "0.1.0-alpha01"
    implementation("io.github.captnblubber:twitchkt-helix:$twitchKtVersion")      // Helix REST API
    implementation("io.github.captnblubber:twitchkt-eventsub:$twitchKtVersion")   // EventSub WebSocket
    implementation("io.github.captnblubber:twitchkt-auth:$twitchKtVersion")       // OAuth2 flows

    // Ktor — pick an engine for your platform
    val ktorVersion = "3.3.3"
    implementation("io.ktor:ktor-client-cio:$ktorVersion")                         // JVM
    // implementation("io.ktor:ktor-client-js:$ktorVersion")                       // JS/Wasm

    // Ktor plugins required by TwitchKt
    implementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
    implementation("io.ktor:ktor-client-websockets:$ktorVersion")                  // EventSub only
}

dependencies {
    // BOM — manages all twitchkt module versions
    implementation(platform("io.github.captnblubber:twitchkt-bom:0.1.0-alpha01"))

    // TwitchKt modules (no version needed with BOM)
    implementation("io.github.captnblubber:twitchkt-helix")
    implementation("io.github.captnblubber:twitchkt-eventsub")
    implementation("io.github.captnblubber:twitchkt-auth")

    // Optional: Kermit logging bridge
    implementation("io.github.captnblubber:twitchkt-logging-kermit")

    // Ktor (still needs an explicit version)
    val ktorVersion = "3.3.3"
    implementation("io.ktor:ktor-client-cio:$ktorVersion")
    implementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
    implementation("io.ktor:ktor-client-websockets:$ktorVersion")                  // EventSub only
}

val httpClient = HttpClient(CIO) {
    install(ContentNegotiation) {
        json()
    }
    install(WebSockets)
}

val config = TwitchKtConfig(
    clientId = "your_client_id",
    tokenProvider = { myTokenStore.getAccessToken() },
)

val helix = TwitchHelix(httpClient, config)

// Look up a user by login name
val users = helix.users.getUsers(logins = listOf("captnblubber"))

// Check if a channel is currently live
val page = helix.streams.getStreams(userLogins = listOf("captnblubber"))
val streams = page.data

// Update the stream title (requires channel:manage:broadcast scope)
helix.channels.update(
    broadcasterId = "123456",
    request = UpdateChannelRequest(title = "New stream title"),
)

// Option 1: Auto-paginate with Flow — fetches all pages as you collect
helix.followers.listAll(broadcasterId = "123456").collect { follower ->
    println(follower.userLogin)
}

// Option 2: Single page with manual cursor control
val page = helix.followers.list(broadcasterId = "123456", pageSize = 50)
page.data.forEach { println(it.userLogin) }

// Fetch the next page using the cursor
val nextPage = helix.followers.list(broadcasterId = "123456", cursor = page.cursor)

val eventSub = TwitchEventSub(httpClient, config, helix.eventSub)

// Register subscriptions before connecting
eventSub.subscribe(EventSubSubscriptionType.ChannelFollow(broadcasterId, moderatorId))
eventSub.subscribe(EventSubSubscriptionType.StreamOnline(broadcasterId))

// Connect — manages keepalives and reconnects automatically
eventSub.connect(coroutineScope)

// All incoming events arrive on this flow as typed sealed classes
eventSub.events.collect { event ->
    when (event) {
        is ChannelFollow -> println("New follower: ${event.userName}")
        is ChannelSubscribe -> println("New sub: ${event.userName} tier ${event.tier}")
        is StreamOnline -> println("Stream started!")
        else -> { }
    }
}

val auth = TwitchAuth(httpClient, clientId = "your_client_id", clientSecret = "your_client_secret")

// Build the URL to redirect users to for authorization
val url = auth.authorizationUrl(
    scopes = setOf(TwitchScope.CHAT_READ, TwitchScope.CHANNEL_READ_SUBSCRIPTIONS),
    redirectUri = "http://localhost:8080/callback",
)

// Exchange the code Twitch returns for an access + refresh token pair
val tokens = auth.exchangeCode(code = "abc123", redirectUri = "http://localhost:8080/callback")

// Refresh when the access token expires
val newTokens = auth.refresh(refreshToken = tokens.refreshToken)

try {
    helix.channels.update(broadcasterId, request)
} catch (e: TwitchApiException.RateLimited) {
    delay(e.retryAfterMs)
} catch (e: TwitchApiException.Forbidden) {
    // Missing OAuth scope — check @RequiresScope on the method
}