package com.example
import it.tdlight.common.ExceptionHandler
import it.tdlight.common.Init
import it.tdlight.common.ResultHandler
import it.tdlight.common.TelegramClient
import it.tdlight.jni.TdApi
import it.tdlight.tdlight.ClientManager
import org.slf4j.Logger
import org.slf4j.LoggerFactory
val logger: Logger = LoggerFactory.getLogger("MY_OWN_LOGGER")
val chatId: Long = System.getenv("TELEGRAM_RECIPIENT_CHAT_ID").toLong()
/**
* FIXME: Aint working yet
*/
fun main() {
val client: TelegramClient = ClientManager.create()
//
val updateAuthorizationStateHandler = UpdateAuthorizationStateHandler(::onSuccessAuthorization)
//
val updateHandler = UpdateHandler()
val updateExceptionHandler = UpdateExceptionHandler()
val defaultExceptionHandler = DefaultExceptionHandler()
//
Init.start()
client.initialize(UpdateHandler(), updateExceptionHandler, defaultExceptionHandler)
}
private fun onSuccessAuthorization() {
var userInput: String = readln()
while (userInput != "exit") {
// sendMessage(chatId = chatId, message = userInput)
userInput = readln()
}
}
private fun sendMessage(chatId: Long, message: String) {
client.send(TdApi.SendMessage().apply {
this.chatId = chatId
inputMessageContent = TdApi.InputMessageText().apply {
text = TdApi.FormattedText().apply { text = message }
}
}) {
when (it) {
is TdApi.Error -> {
throw RuntimeException(
it.message,
Throwable("Error ${it.code}: ${it.message}")
)
}
else -> logger.info("Successfully sent message to $chatId with text $message")
}
}
}
private class UpdateHandler(): ResultHandler<TdApi.Update> {
override fun onResult(update: TdApi.Object) {
when (update) {
is TdApi.UpdateAuthorizationState -> {
println("!!!!")
updateAuthorizationStateHandler(
authState = update.authorizationState,
onSuccessAuthorizationCallBack = ::onSuccessAuthorization
)
}
is TdApi.UpdateOption -> {
// version OptionValueString { value = "1.8.7" }
// commit_hash OptionValueString { value = "ref: refs/heads/master" }
logger.info("${update.name} ${update.value}")
}
else -> logger.warn("Update type ${update.javaClass} not supported")
}
}
}
private fun updateAuthorizationStateHandler(
authState: TdApi.Object,
onSuccessAuthorizationCallBack: () -> Unit
) {
when (authState) {
is TdApi.AuthorizationStateWaitTdlibParameters -> {
val parameters = TdApi.SetTdlibParameters().apply {
databaseDirectory = "tdlib"
useMessageDatabase = true
useSecretChats = true
apiId = Settings.telegramApiId
apiHash = Settings.telegramApiHash
systemLanguageCode = "en"
deviceModel = "Desktop"
applicationVersion = "0.1.0"
enableStorageOptimizer = true
}
println("cant send something BEFORE something")
client.send(
parameters,
{
println("cant send something AFTER something")
},
// AuthResultHandler("Tdlib parameters set"),
DefaultExceptionHandler()
)
}
is TdApi.AuthorizationStateWaitPhoneNumber -> client.send(
TdApi.SetAuthenticationPhoneNumber(
Settings.senderPhone,
null
),
AuthResultHandler("Authentication phone sent"
)
)
is TdApi.AuthorizationStateWaitCode -> {
print("Enter code: ")
val code = readln()
client.send(
TdApi.CheckAuthenticationCode(code),
AuthResultHandler("Code verified")
)
}
is TdApi.AuthorizationStateWaitPassword -> {
print("Enter password: ")
val password = readln()
client.send(
TdApi.CheckAuthenticationPassword(password),
AuthResultHandler("Password verified")
)
}
is TdApi.AuthorizationStateReady -> onSuccessAuthorizationCallBack.invoke()
else -> logger.warn("Auth state $authState not supported")
}
}
private class UpdateAuthorizationStateHandler(
private val onSuccessAuthorizationCallBack: () -> Unit
): ResultHandler<TdApi.Ok> {
override fun onResult(authState: TdApi.Object) {
when (authState) {
is TdApi.AuthorizationStateWaitTdlibParameters -> {
val parameters = TdApi.SetTdlibParameters().apply {
databaseDirectory = "tdlib"
useMessageDatabase = true
useSecretChats = true
apiId = Settings.telegramApiId
apiHash = Settings.telegramApiHash
systemLanguageCode = "en"
deviceModel = "Desktop"
applicationVersion = "0.1.0"
enableStorageOptimizer = true
}
client.send(
parameters,
AuthResultHandler("Tdlib parameters set"),
DefaultExceptionHandler()
)
}
is TdApi.AuthorizationStateWaitPhoneNumber -> client.send(
TdApi.SetAuthenticationPhoneNumber(
Settings.senderPhone,
null
),
AuthResultHandler("Authentication phone sent"
)
)
is TdApi.AuthorizationStateWaitCode -> {
print("Enter code: ")
val code = readln()
client.send(
TdApi.CheckAuthenticationCode(code),
AuthResultHandler("Code verified")
)
}
is TdApi.AuthorizationStateWaitPassword -> {
print("Enter password: ")
val password = readln()
client.send(
TdApi.CheckAuthenticationPassword(password),
AuthResultHandler("Password verified")
)
}
is TdApi.AuthorizationStateReady -> onSuccessAuthorizationCallBack.invoke()
else -> logger.warn("Auth state $authState not supported")
}
}
}
private class AuthResultHandler(
private val status: String
): ResultHandler<TdApi.Ok> {
override fun onResult(authResult: TdApi.Object) {
when (authResult) {
is TdApi.Error -> logger.error("Auth error: $authResult")
else -> logger.info(status)
}
}
}
private class UpdateExceptionHandler: ExceptionHandler {
override fun onException(exception: Throwable) {
logger.error(exception.message, exception)
}
}
private class DefaultExceptionHandler: ExceptionHandler {
override fun onException(exception: Throwable) {
logger.error(exception.message, exception)
}
}