implementation("me.anasmusa:telegram-login:<version>")

@Composable
fun LoginScreen(onResult: (TelegramLoginResult) -> Unit) {
    TelegramLoginButton(
        config = TelegramLoginConfig(
            clientId = 123456789L,
            redirectURI = "https://yourapp.com/callback",
        ),
        onResult = onResult,
        modifier = Modifier.fillMaxWidth(),
    ) {
        Text("Log in with Telegram")
    }
}

TelegramLoginButton(
    config = config,
    onResult = { result ->
        when (result) {
            is TelegramLoginResult.Success -> {
                val user = result.user
                println("Logged in as ${user.name} (id=${user.id})")
                // result.idToken  — raw JWT ID token for server-side validation
                // user.id, user.name, user.preferredUsername,
                // user.picture, user.phoneNumber, user.nonce,
                // user.iss, user.aud, user.iat, user.exp
            }
            is TelegramLoginResult.Cancelled -> {
                println("Login cancelled")
            }
        }
    },
    modifier = Modifier.fillMaxWidth(),
) {
    Text("Log in with Telegram")
}

var showDialog by remember { mutableStateOf(false) }

FilledIconButton(onClick = { showDialog = true }) {
    Icon(imageVector = TelegramDefaults.icon, contentDescription = null)
}

if (showDialog) {
    TelegramLoginDialog(
        config = config,
        onResult = { result ->
            showDialog = false
            onResult(result)
        },
    )
}

TelegramLoginView(
    config = TelegramLoginConfig(
        clientId = 123456789L,
        redirectURI = "https://yourapp.com/callback",
    ),
    modifier = Modifier.fillMaxSize(),
    onResult = onResult,
)

data class TelegramLoginConfig(
    val clientId: Long,
    val redirectURI: String,
    val requestDirectMessages: Boolean = true, // request permission to send direct messages to the user (bot_access scope)
    val requestPhoneNumber: Boolean = false,   // request access to the user's phone number (phone scope)
    val nonce: String? = null,                 // optional nonce to protect against ID token replay attacks
    val languageCode: String? = null,
    val uiMode: UiMode = UiMode.Unspecified,   // Light, Dark, or system/default
)

sealed interface TelegramLoginResult {
    data class Success(
        val idToken: String,          // an OIDC JWT token containing user claims — validate on your server
        val user: TelegramUserData,   // Decoded id_token, containing the requested user info
    ) : TelegramLoginResult

    data object Cancelled : TelegramLoginResult
}

data class TelegramUserData(
    val id: Long,
    val name: String,
    val preferredUsername: String?,
    val picture: String?,
    val phoneNumber: String?,
    val nonce: String?,
    // JWT standard claims
    val iss: String,
    val aud: String,
    val iat: Long,
    val exp: Long,
)

enum class UiMode { Light, Dark, Unspecified }

implementation("me.anasmusa:telegram-login-widget:<version>")

@Composable
fun LoginScreen(onResult: (TelegramLoginResult) -> Unit) {
    val state = rememberTelegramLoginState(
        botId = 123456789L,
        botUsername = "your_bot",
        websiteUrl = "https://yourdomain.com",
    )

    TelegramLoginButton(
        state = state,
        onResult = onResult,
        modifier = Modifier.fillMaxWidth(),
    )
}

TelegramLoginButton(
    state = state,
    onResult = { result ->
        when (result) {
            is TelegramLoginResult.Success -> {
                println("Logged in as ${result.firstName} (id=${result.id})")
                // result.id, result.firstName, result.lastName,
                // result.username, result.photoUrl, result.authDate, result.hash
            }
            is TelegramLoginResult.Cancelled -> {
                println("Login cancelled")
            }
        }
    },
)

TelegramLoginOutlinedButton(
    state = state,
    onResult = onResult,
    modifier = Modifier.fillMaxWidth(),
)

// Light-themed button with Telegram-colored icon
TelegramLoginButton(
    state = state,
    onResult = onResult,
    modifier = Modifier.fillMaxWidth(),
    left = {
        TelegramButtonIcon(tint = TelegramDefaults.primaryColor)
    },
    colors = TelegramDefaults.buttonColors(
        containerColor = Color.White,
        contentColor = Color.Black,
    ),
)

// Centered text with the user avatar placed next to the label
TelegramLoginButton(
    state = state,
    onResult = onResult,
    modifier = Modifier.fillMaxWidth(),
    center = {
        Row(
            modifier = Modifier.weight(1f),
            horizontalArrangement = Arrangement.Center,
            verticalAlignment = Alignment.CenterVertically,
        ) {
            TelegramButtonText(
                state = it,
                modifier = Modifier.weight(weight = 1f, fill = false),
            )
            TelegramButtonUserPhotoBox(state = it)
        }
    },
    right = null,
)

var showBottomSheet by remember { mutableStateOf(false) }

FilledIconButton(onClick = { showBottomSheet = true }) {
    Icon(imageVector = TelegramDefaults.icon, contentDescription = null)
}

if (showBottomSheet) {
    TelegramLoginBottomSheet(
        config = state.config,
        onResult = { result ->
            showBottomSheet = false
            state.reload()
            onResult(result)
        },
    )
}

TelegramLoginView(
    config = TelegramLoginConfig(
        botId = 123456789,
        botUsername = "your_bot",
        websiteUrl = "https://yourdomain.com",
    ),
    modifier = Modifier.fillMaxSize(),
    onResult = onResult,
)

// If you have a state object
state.logout()

// If you don't have a state object
TelegramLoginManager.logout()

fun rememberTelegramLoginState(
    botId: Long,
    botUsername: String,
    websiteUrl: String,
    requestAccess: Boolean = true,   // request permission to send messages
    languageCode: String = "en",
): TelegramLoginState

sealed interface TelegramLoginResult {
    data class Success(
        val id: Long,
        val firstName: String,
        val lastName: String?,
        val username: String?,
        val photoUrl: String?,
        val authDate: Long,
        val hash: String,         // verify on your server
    ) : TelegramLoginResult

    data object Cancelled : TelegramLoginResult
}