Telego

https://telego.pixelbox.dev/docs/introduction/overview
Admin
Telego is a Go library designed for one-to-one implementation of the Telegram Bot API. It provides...
Tokens:5,433
Snippets:40
Trust Score:5.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Complete Telego Echo Bot Example

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This comprehensive Go program demonstrates a fully functional 'echo' bot using the Telego library. It includes all necessary steps from environment setup and bot initialization to receiving and responding to messages via long polling, providing a complete runnable example.

```go
package main

import (
    "fmt"
    "os"

    "github.com/mymmrac/telego"
    th "github.com/mymmrac/telego/telegohandler"
    tu "github.com/mymmrac/telego/telegoutil"
)

func main() {
    botToken := os.Getenv("TOKEN")

    bot, err := telego.NewBot(botToken, telego.WithDefaultDebugLogger())
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    botUser, err := bot.GetMe()
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    fmt.Printf("Bot user: %+v\n", botUser)

    updates, _ := bot.UpdatesViaLongPolling(nil)

    bh, _ := th.NewBotHandler(bot, updates)

    bh.HandleMessage(func(bot *telego.Bot, message telego.Message) {
        chatID := tu.ID(message.Chat.ID)
        _, _ = bot.CopyMessage(
            tu.CopyMessage(chatID, chatID, message.MessageID),
        )
    })

    defer bh.Stop()
    defer bot.StopLongPolling()

    bh.Start()
}
```

--------------------------------

### Install Telego Library

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This command uses Go's package manager to download and install the Telego library, making it available for use in your Go projects. It fetches the necessary dependencies from the specified GitHub repository.

```go
go get github.com/mymmrac/telego
```

--------------------------------

### Import Telego Packages in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This Go code snippet imports the necessary Telego packages and standard library modules required for building a Telegram bot. It includes `fmt` for formatting, `os` for environment variables, and specific Telego modules for bot functionality, handlers, and utilities.

```go
import (
    "fmt"
    "os"

    "github.com/mymmrac/telego"
    th "github.com/mymmrac/telego/telegohandler"
    tu "github.com/mymmrac/telego/telegoutil"
)
```

--------------------------------

### Install Telego Library

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This command installs the Telego library for Go projects. It fetches the latest version from GitHub and adds it to your Go module dependencies, making it available for import in your application.

```bash
go get github.com/mymmrac/telego
```

--------------------------------

### Get and Print Telego Bot Information

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This Go code retrieves the bot's user information using the `GetMe` method and prints it to the console. It includes error handling to ensure the bot was properly configured and can communicate with the Telegram API.

```go
botUser, err := bot.GetMe()
if err != nil {
    fmt.Println(err)
    os.Exit(1)
}

fmt.Printf("Bot user: %+v\n", botUser)
```

--------------------------------

### Create Telego Bot Instance

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This Go snippet initializes a new Telego bot instance using a token retrieved from an environment variable. It includes error handling and enables a default debug logger for development purposes, warning against its use in production due to sensitive information exposure.

```go
botToken := os.Getenv("TOKEN")

bot, err := telego.NewBot(botToken, telego.WithDefaultDebugLogger())
if err != nil {
    fmt.Println(err)
    os.Exit(1)
}
```

--------------------------------

### Telegram Bot API Core Concepts

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

References to fundamental concepts of the Telegram Bot API, including how to authorize a bot, make requests to the API, and receive updates from Telegram servers. These are essential for understanding bot capabilities and interactions.

```APIDOC
Telegram Bot API:
  - Authorizing your bot: Process of obtaining and using a bot token to authenticate your bot with Telegram servers.
  - Making requests: How to send API calls (e.g., sendMessage, getUpdates) to Telegram's servers using HTTP.
  - Getting updates: Methods for receiving new messages and events from users or channels, typically via long polling or webhooks.
```

--------------------------------

### Handle Telego Messages with Echo Functionality

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This Go code sets up a bot handler to process incoming messages. It registers a message handler that copies any received message back to the sender, effectively creating an 'echo' bot. `defer` statements ensure the handler is stopped gracefully.

```go
bh, _ := th.NewBotHandler(bot, updates)

bh.HandleMessage(func(bot *telego.Bot, message telego.Message) {
    chatID := tu.ID(message.Chat.ID)
    _, _ = bot.CopyMessage(
        tu.CopyMessage(chatID, chatID, message.MessageID),
    )
})

defer bh.Stop()
// ...

bh.Start()
```

--------------------------------

### Start Telego Updates via Long Polling

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/quick-start

This Go snippet initiates the process of receiving updates from Telegram using long polling. It's a basic method for fetching new messages and events, though the documentation notes it's not always recommended for production use. A `defer` statement ensures long polling is stopped when the function exits.

```go
updates, _ := bot.UpdatesViaLongPolling(nil)
// ...
defer bot.StopLongPolling()
```

--------------------------------

### Telego Bot Webhook Options

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/configuration

Describes optional arguments for `telego.Bot.UpdatesViaWebhook` to configure the server, context, buffer size, and webhook setup for receiving updates via webhooks.

```APIDOC
telego.Bot.UpdatesViaWebhook Options:
  WithWebhookServer:
    Description: FastHTTP server to use for webhook listening
    Default: &telego.FastHTTPWebhookServer
  WithWebhookContext:
    Description: Specify context passed into each update when received
    Default: not set
  WithWebhookBuffer:
    Description: Buffer size of update channel that will be returned
    Default: 128
  WithWebhookSet:
    Description: Call bot.SetWebhook with specified telego.SetWebhookParams before starting the webhook
```

--------------------------------

### Full Go Telego Bot Graceful Shutdown Example

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This comprehensive Go example showcases a complete graceful shutdown implementation for a `telego` bot. It integrates signal handling to detect termination requests, gracefully stops the bot's long polling mechanism, and ensures all ongoing update processing is completed before the application exits cleanly.

```Go
package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/mymmrac/telego"
)

func main() {
    botToken := os.Getenv("TOKEN")

    bot, err := telego.NewBot(botToken, telego.WithDefaultDebugLogger())
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    done := make(chan struct{}, 1)

    updates, _ := bot.UpdatesViaLongPolling(nil)

    for update := range updates {
        fmt.Println("Processing update:", update.UpdateID)
        time.Sleep(time.Second * 5) // Simulate long process time
        fmt.Println("Done update:", update.UpdateID)
    }

    go func() {
        <-sigs

        fmt.Println("Stopping...")

        bot.StopLongPolling()
        fmt.Println("Long polling done")

        done <- struct{}{}
    }()

    <-done
    fmt.Println("Done")
}
```

--------------------------------

### Start Long Polling with Telego Helper

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This Go code uses Telego's built-in helper to start long polling for Telegram updates. It simplifies the process by handling the infinite loop, offset management, and retries, returning a read-only channel for receiving updates.

```go
// Returns <-chan telego.Update
updates, err := bot.UpdatesViaLongPolling(nil)
```

--------------------------------

### Go Telego Bot Graceful Shutdown with Handler Example

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This Go example demonstrates graceful shutdown for a `telego` bot utilizing `telegohandler` for update processing. It ensures that both the bot's long polling and the handler's operations are cleanly stopped upon receiving termination signals, preventing data loss and resource leaks during application exit.

```Go
package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/mymmrac/telego"
    th "github.com/mymmrac/telego/telegohandler"
)

func main() {
    botToken := os.Getenv("TOKEN")

    bot, err := telego.NewBot(botToken, telego.WithDefaultDebugLogger())
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    done := make(chan struct{}, 1)

    updates, _ := bot.UpdatesViaLongPolling(nil)

    bh, _ := th.NewBotHandler(bot, updates, th.WithStopTimeout(time.Second*10))

    bh.Handle(func(bot *telego.Bot, update telego.Update) {
        fmt.Println("Processing update:", update.UpdateID)
        time.Sleep(time.Second * 5) // Simulate long process time
        fmt.Println("Done update:", update.UpdateID)
    })

    go func() {
        <-sigs

        fmt.Println("Stopping...")

        bot.StopLongPolling()
        fmt.Println("Long polling done")

        bh.Stop()
        fmt.Println("Bot handler done")

        done <- struct{}{}
    }()

    go bh.Start()
    fmt.Println("Handling updates...")

    <-done
    fmt.Println("Done")
}
```

--------------------------------

### Retrieve Bot User Information (GetMe)

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This snippet calls the `GetMe` Telegram API method via the Telego bot instance to retrieve information about the bot itself. It includes error handling and prints the bot's user details, serving as a health check before starting main bot functionality.

```go
botUser, err := bot.GetMe()
if err != nil {
    fmt.Println(err)
    os.Exit(1)
}

fmt.Printf("Bot user: %+v\n", botUser)
```

--------------------------------

### Fetch Telegram Updates Manually (Single Call)

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This Go code demonstrates a single call to the `GetUpdates` Telegram API method using Telego. It retrieves a slice of unhandled updates, starting from a specified offset, and is typically used as part of a long-polling loop.

```go
// Returns []telego.Update
updates, err := bot.GetUpdates(&telego.GetUpdatesParams{ Offset: 0 })
```

--------------------------------

### Import Telego and Standard Libraries

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This Go code snippet imports necessary packages for a Telego bot application. It includes `fmt` for formatting output, `os` for environment variable access (e.g., bot token), and the `telego` library itself.

```go
import (
    "fmt"
    "os"

    "github.com/mymmrac/telego"
)
```

--------------------------------

### Initialize Telego Bot Instance

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This snippet demonstrates how to create a new Telego bot instance using a token retrieved from environment variables. It includes basic error handling, printing the error and exiting if bot creation fails, emphasizing secure token management.

```go
botToken := os.Getenv("TOKEN")

bot, err := telego.NewBot(botToken)
if err != nil {
    fmt.Println(err)
    os.Exit(1)
}
```

--------------------------------

### Processing Updates in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Demonstrates a basic loop to iterate and process incoming updates one by one from a channel.

```Go
for update := range updates {
    fmt.Printf("Update: %+v\n", update)
    // Handle update ...
}
```

--------------------------------

### Importing Telego Utilities Package in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Shows how to import the `telegoutil` package, aliased as `tu`, for convenient access to common utility methods in Telego.

```Go
import tu "github.com/mymmrac/telego/telegoutil"
```

--------------------------------

### Sending Messages with Telego Utilities in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Demonstrates how to use `telegoutil` methods like `tu.Message` and `tu.CopyMessage` to simplify sending and copying messages with all required parameters.

```Go
_, err := bot.SendMessage(tu.Message(tu.ID(1234567), "Hello Telego!"))
// Or to copy message
chatID := tu.ID(message.Chat.ID)
_, err := bot.CopyMessage(tu.CopyMessage(chatID, chatID, message.MessageID))
```

--------------------------------

### Creating and Stopping a Telego Bot Handler in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Illustrates the creation of a new bot handler instance using `th.NewBotHandler` with a bot and updates channel, and how to stop it gracefully.

```Go
// You are still getting updates via chanel
bh, err := th.NewBotHandler(bot, updates)

// ...

// Stop at the end ...
bh.Stop()
```

--------------------------------

### Import Go Packages for Signal Handling

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This Go snippet imports essential packages for robust signal handling in applications. It includes `os` for operating system interactions, `os/signal` for managing system signals, and `syscall` for low-level system calls, all critical for implementing graceful shutdowns.

```Go
import (
    "os"
    "os/signal"
    "syscall"
)
```

--------------------------------

### Importing Telego Bot Handler Package in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Shows how to import the `telegohandler` package, aliased as `th`, for convenient use of Telego's bot handling functionalities.

```Go
import th "github.com/mymmrac/telego/telegohandler"
```

--------------------------------

### Refining Inline Keyboard Creation with Telego With... Methods

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Illustrates the use of `With...` methods (e.g., `WithCallbackData`, `WithURL`, `WithSwitchInlineQueryCurrentChat`) to modify `InlineKeyboardButton` parameters. This approach allows for chaining methods and avoids explicit variable creation or using struct literals, offering a more concise and fluent way to build reply markups.

```Go
// ...
ReplyMarkup: tu.InlineKeyboard(
    tu.InlineKeyboardRow(
        tu.InlineKeyboardButton("Callback").WithCallbackData("data"),
        tu.InlineKeyboardButton("URL").WithURL("https://example.com"),
    ),
    tu.InlineKeyboardRow(
        tu.InlineKeyboardButton("Switch to Inline").
            WithSwitchInlineQueryCurrentChat("telego"),
    ),
),
```

--------------------------------

### Telego Bot Options API Documentation

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/configuration

This section provides a comprehensive list of optional arguments that can be passed to `telego.NewBot` after the bot token. These options allow for customization of various bot behaviors, including API server URL, logging, HTTP client, and request construction. Understanding these options is crucial for fine-tuning Telego's functionality.

```APIDOC
WithAPIServer:
  Description: Change the bot API server URL.
  Default: https://api.telegram.org
```

```APIDOC
WithLogger:
  Description: Create a custom logger that implements `telego.Logger`.
  Default: Telego's built-in default logger.
  Note: Logger may expose sensitive information; use in development only or configure carefully.
```

```APIDOC
WithDefaultLogger:
  Description: Configure the default logger, enabling printing of debug information and errors.
  Default: debug=false, errors=true
```

```APIDOC
WithDefaultDebugLogger:
  Description: Default logger with enabled debug logs.
  Default: logger with enabled debug logs
```

```APIDOC
WithExtendedDefaultLogger:
  Description: Same as `WithDefaultLogger`, but allows specifying a `strings.Replacer` for log content.
  Default: If used, default logger replaces bot token with `BOT_TOKEN`.
```

```APIDOC
WithDiscardLogger:
  Description: Disable all logs.
```

```APIDOC
WithHealthCheck:
  Description: Run the `getMe` method on bot creation for a health check.
```

```APIDOC
WithWarnings:
  Description: Treat any warnings as errors (e.g., deleting an already deleted webhook).
```

```APIDOC
WithFastHTTPClient:
  Description: Specify a custom `valyala/fasthttp` client for making requests.
  Default: `&fasthttp.Client{}`
```

```APIDOC
WithHTTPClient:
  Description: Use a client from `net/http` as an alternative to the fasthttp client.
```

```APIDOC
WithEmptyValues:
  Description: Used with `telego.Bot.EmptyValue()` for valid empty string parameters.
  Default: No empty value is set; `telego.Bot.EmptyValue()` does nothing.
  When enabled: `telego.Bot.EmptyValue()` returns `TELEGO_EMPTY_VALUE`, which is erased from the request.
```

```APIDOC
WithCustomEmptyValues:
  Description: Same as `WithEmptyValues`, but allows setting a custom "empty value" string.
```

```APIDOC
WithAPICaller:
  Description: Provide a custom implementation of `telegoapi.Caller`.
  Default: `telegoapi.FasthttpAPICaller`
```

```APIDOC
WithRequestConstructor:
  Description: Provide a custom way of constructing requests for both regular (JSON) and multipart (key-value & files) requests.
  Default: `telegoapi.DefaultConstructor`
```

```APIDOC
WithTestServerPath:
  Description: Use the test server API path instead of the regular API path.
  Regular API (default): `https://<api-server>/bot<token>/<method-name>`
  Test API: `https://<api-server>/bot<token>/test/<method-name>`
```

--------------------------------

### Sending Inline Keyboard with Telego Utility Methods

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Demonstrates how to send an inline keyboard using Telego's utility methods (`tu.ID`, `tu.InlineKeyboard`, `tu.InlineKeyboardRow`, `telego.InlineKeyboardButton`) to construct the `ReplyMarkup` for a `SendMessageParams` struct. Highlights that `telego.InlineKeyboardButton` requires a `text` parameter and exactly one of the optional parameters (callback data, URL, etc.) should be set.

```Go
_, err := bot.SendMessage(&telego.SendMessageParams{
    ChatID: tu.ID(1234567),
    Text: "Awesome Keyboard",
    ReplyMarkup: tu.InlineKeyboard(
        tu.InlineKeyboardRow(
            telego.InlineKeyboardButton{
                Text: "Callback",
                CallbackData: "data",
            },
            telego.InlineKeyboardButton{
                Text: "URL",
                URL: "https://example.com",
            },
        ),
        tu.InlineKeyboardRow(
            telego.InlineKeyboardButton{
                Text: "Switch to Inline",
                SwitchInlineQueryCurrentChat: "telego",
            },
        ),
    ),
})
```

--------------------------------

### Registering a General Purpose Bot Handler in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Demonstrates how to register a general purpose handler with `bh.Handle` that processes any update matching a specified predicate, such as `th.AnyMessage()`.

```Go
bh.Handle(func(bot *telego.Bot, update telego.Update) {
    fmt.Printf("Update: %+v\n", update)
    // Handle update ...
}, th.AnyMessage())
```

--------------------------------

### Initialize Telego Bot with Debug Logger

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This Go code shows how to initialize a Telego bot with a default debug logger enabled. The `telego.WithDefaultDebugLogger()` option configures the bot to print debug information and errors, which is useful for development and troubleshooting.

```go
bot, err := telego.NewBot(botToken, telego.WithDefaultDebugLogger())
```

--------------------------------

### Creating Telego Chat IDs Using Utilities in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Illustrates the use of `tu.ID` and `tu.Username` utility methods to easily create `telego.ChatID` instances from an integer ID or a string username.

```Go
chatID := tu.ID(1234567)
// Or
chatID := tu.Username("@telegram")
```

--------------------------------

### Copying Any Message Back (Echo Bot) in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Demonstrates how to use `bot.CopyMessage` to send a copy of any incoming message (text, photo, voice, etc.) back to the original chat, enhancing the echo bot functionality.

```Go
// Handle updates ...
chatID := telego.ChatID{ ID: message.Chat.ID }
sentMessageID, err := bot.CopyMessage(&telego.CopyMessageParams{
    ChatID:     chatID,
    FromChatID: chatID,
    MessageID:  message.MessageID,
})
```

--------------------------------

### Sending a Text Message Back (Echo Bot) in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Illustrates how to use `bot.SendMessage` within a message handler to send a text message back to the user's chat, creating a basic echo bot.

```Go
bh.HandleMessage(func(bot *telego.Bot, message telego.Message) {
    chatID := message.Chat.ID
    sentMessage, err := bot.SendMessage(&telego.SendMessageParams{
        ChatID: telego.ChatID{ID: chatID},
        Text:   message.Text,
    })
    // ...
})
```

--------------------------------

### Registering a Specific Message Handler in Go

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

Shows how to register a handler specifically for message updates using `bh.HandleMessage`, which automatically filters for non-nil messages.

```Go
bh.HandleMessage(func(bot *telego.Bot, message telego.Message) {
    fmt.Printf("Message: %+v\n", message)
    // Handle message ...
})
```

--------------------------------

### Telego Bot Handler Options

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/configuration

Describes optional arguments for `th.NewBotHandler` to configure the stop timeout and the use of a done signal for controlling the bot handler's lifecycle.

```APIDOC
th.NewBotHandler Options:
  WithStopTimeout:
    Description: Wait for updates to be processed for specified time
    Default: 0s (stop immediately)
  WithDone:
    Description: Wait for a done message to stop bot handler
    Default: not set
```

--------------------------------

### Initialize Go Channels for Graceful Shutdown

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This Go code initializes the necessary channels for a graceful shutdown process. `sigs` is a buffered channel designed to capture system signals like `SIGINT` and `SIGTERM`, while `done` is another buffered channel used to signal the completion of all shutdown procedures.

```Go
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

done := make(chan struct{}, 1)
```

--------------------------------

### Implement Go Goroutine for Signal Processing

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This Go snippet demonstrates how to process system signals within a dedicated goroutine. It waits for a termination signal, allowing for the execution of cleanup tasks before notifying the main program via the `done` channel that the shutdown sequence is complete.

```Go
go func () {
    // Wait for stop signal
    <-sigs

    // Stop any tasks here ...

    // Notify that stop is done
    done <- struct{}{}
}()
```

--------------------------------

### Go Telego Bot Webhook Graceful Shutdown

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This Go program sets up a Telego bot to receive updates via webhook. It includes a robust graceful shutdown mechanism that listens for OS signals (SIGINT, SIGTERM). Upon receiving a signal, it stops the webhook listener and the bot handler, ensuring all resources are released cleanly. The webhook operation is non-blocking, allowing for concurrent update processing.

```Go
package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/mymmrac/telego"
    th "github.com/mymmrac/telego/telegohandler"
)

func main() {
    botToken := os.Getenv("TOKEN")

    bot, err := telego.NewBot(botToken, telego.WithDefaultDebugLogger())
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    done := make(chan struct{}, 1)

    updates, _ := bot.UpdatesViaWebhook("/bot" + bot.Token())

    bh, _ := th.NewBotHandler(bot, updates, th.WithStopTimeout(time.Second*10))

    bh.Handle(func(bot *telego.Bot, update telego.Update) {
        fmt.Println("Processing update:", update.UpdateID)
        time.Sleep(time.Second * 5) // Simulate long process time
        fmt.Println("Done update:", update.UpdateID)
    })

    go func() {
        <-sigs

        fmt.Println("Stopping...")

        _ = bot.StopWebhook()
        fmt.Println("Webhook done")

        bh.Stop()
        fmt.Println("Bot handler done")

        done <- struct{}{}
    }()

    go bh.Start()
    fmt.Println("Handling updates...")

    _ = bot.StartListeningForWebhook("localhost:443")

    <-done
    fmt.Println("Done")
}
```

--------------------------------

### Implement Manual Long Polling for Updates

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This Go snippet illustrates a manual long-polling loop to continuously fetch Telegram updates. It sets an offset to retrieve new updates, includes a timeout for efficiency, and updates the offset after processing to ensure only new updates are fetched.

```go
offset := 0
for {
    updates, err := bot.GetUpdates(&telego.GetUpdatesParams{
        Offset: offset,
        Timeout: 5,
    })
    // Handle error ...

    offset = updates[len(updates) - 1].UpdateID + 1
}
```

--------------------------------

### Wait for Go Program Shutdown Completion

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/graceful-shutdown

This Go code illustrates the final step in a graceful shutdown, where the main program waits for all termination processes to conclude. It blocks until a signal is received on the `done` channel, ensuring that all background tasks and cleanup operations have finished before the application exits.

```Go
// Wait for done signal
<-done

// Exit program
```

--------------------------------

### Telego Bot Long Polling Options

Source: https://telego.pixelbox.dev/docs/introduction/overview/setup/configuration

Describes optional arguments for `telego.Bot.UpdatesViaLongPolling` to configure context, update interval, retry timeout, and buffer size for long polling updates. It also notes the interaction with Telegram's built-in timeout mechanism.

```APIDOC
telego.Bot.UpdatesViaLongPolling Options:
  WithLongPollingContext:
    Description: Specify context passed into each update when received
    Default: not set
  WithLongPollingUpdateInterval:
    Description: Update interval for long polling, ensures a minimum time between GetUpdates calls.
    Default: 0s
    Note: Telegram has a built-in timeout mechanism. For proper use, set telego.GetUpdatesParams.Timeout and update interval to 0.
  WithLongPollingRetryTimeout:
    Description: Interval before trying to get updates after an error
    Default: 8s
  WithLongPollingBuffer:
    Description: Buffer size of update channel that will be returned
    Default: 100
Note: If telego.GetUpdatesParams is nil, a default timeout of 8s will be applied.
```

--------------------------------

### Stop Telego Long Polling Helper

Source: https://telego.pixelbox.dev/docs/introduction/overview/introduction/tutorial

This Go snippet demonstrates how to stop the long-polling process initiated by Telego's helper method. Calling `StopLongPolling()` gracefully terminates the update fetching loop, releasing resources associated with the long-polling mechanism.

```go
bot.StopLongPolling()
```
Tokens:
Raw