interface TokenService {
    /**
     * Get token from service
     * @return TokenInfo Token information including expiration time
     */
    suspend fun getToken(): TokenInfo
}

data class TokenInfo(
    val token: String?,      // Access token
    val expiresIn: Long      // Expiration time in seconds
)

class PATTokenService(private val token: String) : TokenService {
    override suspend fun getToken(): TokenInfo {
        // Return PAT with a default expiration time
        return TokenInfo(token = token, expiresIn = 3600)
    }
}

class JWTTokenService(
    private val appId: String,
    private val keyId: String,
    private val privateKey: String
) : TokenService {
    override suspend fun getToken(): TokenInfo {
        // Implement JWT token generation logic
        val jwtToken = generateJWTToken(
            appId = appId,
            keyId = keyId,
            privateKey = privateKey
        )
        return TokenInfo(token = jwtToken.accessToken, expiresIn = jwtToken.expiresIn)
    }
}

class OAuthTokenService(
    private val appId: String,
    private val appSecret: String
) : TokenService {
    override suspend fun getToken(): TokenInfo {
        // Implement OAuth token retrieval logic
        val tokenData = getOAuthToken(
            appId = appId,
            appSecret = appSecret
        )
        return TokenInfo(token = tokenData.accessToken, expiresIn = tokenData.expiresIn)
    }
}

// Initialize with PAT
val patService = PATTokenService("your-pat-token")
TokenManager.init(patService)

// Or initialize with JWT
val jwtService = JWTTokenService(
    appId = "your-app-id",
    keyId = "your-key-id",
    privateKey = "your-private-key"
)
TokenManager.init(jwtService)

// Or initialize with OAuth
val oauthService = OAuthTokenService(
    appId = "your-app-id",
    appSecret = "your-app-secret"
)
TokenManager.init(oauthService)

// Create a streaming chat
val chatService = ChatService()
chatService.stream(StreamChatReq(
    botId = "your-bot-id",
    additionalMessages = listOf(EnterMessage("Tell me a joke"))
)).collect { chatData ->
    println(chatData)
}

// Create a non-streaming chat
chatService.createAndPollChat(CreateChatReq(
    botId = "your-bot-id",
    additionalMessages = listOf(EnterMessage("Tell me a joke"))
)).let { result ->
    println(result)
}

val workflowService = WorkflowService()
workflowService.stream(RunWorkflowReq(
    workflowId = "your-workflow-id"
)).collect { workflowData ->
    println(workflowData)
}

val datasetService = DatasetService()
datasetService.create(CreateDatasetReq(
    name = "Test Dataset",
    spaceId = "your-space-id",
    description = "Test description"
)).let { result ->
    println(result)
}

val botService = BotService()

// Create a bot
botService.create(CreateBotReq(
    spaceId = "your-space-id",
    name = "Test Bot",
    description = "A test bot"
)).let { result ->
    println(result)
}

// List published bots
botService.list(ListBotReq(
    spaceId = "your-space-id"
)).let { result ->
    println(result)
}

// Publish a bot
botService.publish(PublishBotReq(
    botId = "your-bot-id",
    connectorIds = listOf("1024") // Agent as API
)).let { result ->
    println(result)
}

val conversationService = ConversationService()

// Create a conversation
conversationService.create(CreateConversationReq(
    botId = "your-bot-id"
)).let { result ->
    println(result)
}

// List conversations
conversationService.list(ListConversationReq(
    botId = "your-bot-id"
)).let { result ->
    println(result)
}

val fileService = FileService()

// Upload a file
fileService.upload(CreateFileReq(
    file = byteArrayOf(), // Your file bytes
    fileName = "test.txt",
    mimeType = "text/plain"
)).let { result ->
    println(result)
}

val workspaceService = WorkspaceService()

// List workspaces
workspaceService.list(WorkspaceListRequest(
    pageNum = 1,
    pageSize = 10
)).let { result ->
    println(result)
}

try {
    val result = chatService.createChat(params)
    println(result)
} catch (e: AuthenticationError) {
    println("Authentication failed: ${e.message}")
} catch (e: BadRequestError) {
    println("Invalid request: ${e.message}")
} catch (e: APIError) {
    println("API error: ${e.message}")
}