Split core and TUI crates

crates/tele-core/src/accounts/mod.rs

@@ -0,0 +1,5 @@
+//! Account profile data structures and validation.
+
+pub mod profile;
+
+pub use profile::{validate_account_name, AccountProfile, AccountsConfig};

crates/tele-core/src/accounts/profile.rs

@@ -0,0 +1,114 @@
+//! Account profile data structures and validation.
+//!
+//! Defines `AccountProfile` and `AccountsConfig` for multi-account support.
+//! Account names are validated to contain only alphanumeric characters, hyphens, and underscores.
+
+use serde::{Deserialize, Serialize};
+
+/// Configuration for all accounts, stored in `~/.config/tele-tui/accounts.toml`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AccountsConfig {
+    /// Name of the default account to use when no `--account` flag is provided.
+    pub default_account: String,
+
+    /// List of configured accounts.
+    pub accounts: Vec<AccountProfile>,
+}
+
+/// A single account profile.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AccountProfile {
+    /// Unique identifier (used in directory names and CLI flag).
+    pub name: String,
+
+    /// Human-readable display name.
+    pub display_name: String,
+}
+
+impl AccountsConfig {
+    /// Creates a default config with a single "default" account.
+    pub fn default_single() -> Self {
+        Self {
+            default_account: "default".to_string(),
+            accounts: vec![AccountProfile {
+                name: "default".to_string(),
+                display_name: "Default".to_string(),
+            }],
+        }
+    }
+
+    /// Finds an account by name.
+    pub fn find_account(&self, name: &str) -> Option<&AccountProfile> {
+        self.accounts.iter().find(|a| a.name == name)
+    }
+}
+
+/// Validates an account name.
+///
+/// Valid names contain only lowercase alphanumeric characters, hyphens, and underscores.
+/// Must be 1-32 characters long.
+///
+/// # Errors
+///
+/// Returns a descriptive error message if the name is invalid.
+pub fn validate_account_name(name: &str) -> Result<(), String> {
+    if name.is_empty() {
+        return Err("Account name cannot be empty".to_string());
+    }
+    if name.len() > 32 {
+        return Err("Account name cannot be longer than 32 characters".to_string());
+    }
+    if !name
+        .chars()
+        .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-' || c == '_')
+    {
+        return Err(
+            "Account name can only contain lowercase letters, digits, hyphens, and underscores"
+                .to_string(),
+        );
+    }
+    if name.starts_with('-') || name.starts_with('_') {
+        return Err("Account name cannot start with a hyphen or underscore".to_string());
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_account_name_valid() {
+        assert!(validate_account_name("default").is_ok());
+        assert!(validate_account_name("work").is_ok());
+        assert!(validate_account_name("my-account").is_ok());
+        assert!(validate_account_name("account_2").is_ok());
+        assert!(validate_account_name("a").is_ok());
+    }
+
+    #[test]
+    fn test_validate_account_name_invalid() {
+        assert!(validate_account_name("").is_err());
+        assert!(validate_account_name("My Account").is_err());
+        assert!(validate_account_name("UPPER").is_err());
+        assert!(validate_account_name("with spaces").is_err());
+        assert!(validate_account_name("-starts-with-dash").is_err());
+        assert!(validate_account_name("_starts-with-underscore").is_err());
+        assert!(validate_account_name(&"a".repeat(33)).is_err());
+    }
+
+    #[test]
+    fn test_default_single_config() {
+        let config = AccountsConfig::default_single();
+        assert_eq!(config.default_account, "default");
+        assert_eq!(config.accounts.len(), 1);
+        assert_eq!(config.accounts[0].name, "default");
+    }
+
+    #[test]
+    fn test_find_account() {
+        let config = AccountsConfig::default_single();
+        assert!(config.find_account("default").is_some());
+        assert!(config.find_account("nonexistent").is_none());
+    }
+}

crates/tele-core/src/constants.rs

@@ -0,0 +1,6 @@
+pub const MAX_MESSAGES_IN_CHAT: usize = 500;
+pub const MAX_USER_CACHE_SIZE: usize = 500;
+pub const MAX_CHATS: usize = 200;
+pub const MAX_CHAT_USER_IDS: usize = 500;
+pub const LAZY_LOAD_USERS_PER_TICK: usize = 5;
+pub const TDLIB_MESSAGE_LIMIT: i32 = 50;

crates/tele-core/src/lib.rs

@@ -0,0 +1,11 @@
+//! Reusable Telegram/TDLib core for tele-tui and future clients.
+
+mod constants;
+mod utils;
+
+pub mod accounts;
+pub mod message_grouping;
+pub mod tdlib;
+#[cfg(any(test, feature = "test-support"))]
+pub mod test_support;
+pub mod types;

crates/tele-core/src/message_grouping.rs

@@ -0,0 +1,447 @@
+//! Модуль для группировки сообщений по дате и отправителю
+//!
+//! Предоставляет функции для логической группировки сообщений
+//! перед отображением, отделяя логику группировки от рендеринга.
+
+use crate::tdlib::MessageInfo;
+use crate::utils::get_day;
+
+/// Элемент группированного списка сообщений
+#[derive(Debug, Clone)]
+pub enum MessageGroup<'a> {
+    /// Разделитель даты (день в формате timestamp)
+    DateSeparator(i32),
+    /// Заголовок отправителя (is_outgoing, sender_name)
+    SenderHeader {
+        is_outgoing: bool,
+        sender_name: String,
+    },
+    /// Сообщение
+    Message(&'a MessageInfo),
+    /// Альбом (группа фото с одинаковым media_album_id)
+    Album(Vec<&'a MessageInfo>),
+}
+
+/// Группирует сообщения по дате и отправителю
+///
+/// # Аргументы
+///
+/// * `messages` - Список сообщений для группировки
+///
+/// # Возвращает
+///
+/// Вектор `MessageGroup` с разделителями дат, заголовками отправителей и сообщениями
+///
+/// # Примеры
+///
+/// ```no_run
+/// use tele_core::message_grouping::{group_messages, MessageGroup};
+///
+/// # use tele_core::tdlib::types::MessageBuilder;
+/// # use tele_core::types::MessageId;
+/// # let msg = MessageBuilder::new(MessageId::new(1)).sender_name("Alice").text("Hello").build();
+/// let messages = vec![msg];
+/// let grouped = group_messages(&messages);
+///
+/// for group in grouped {
+///     match group {
+///         MessageGroup::DateSeparator(_day) => {
+///             // Рендерим разделитель даты
+///         }
+///         MessageGroup::SenderHeader { is_outgoing, sender_name } => {
+///             // Рендерим заголовок отправителя
+///             println!("{}: {}", if is_outgoing { "Outgoing" } else { "Incoming" }, sender_name);
+///         }
+///         MessageGroup::Message(msg) => {
+///             // Рендерим сообщение
+///             println!("{}", msg.text());
+///         }
+///         MessageGroup::Album(messages) => {
+///             // Рендерим альбом (группу фото)
+///             println!("Album with {} photos", messages.len());
+///         }
+///     }
+/// }
+/// ```
+pub fn group_messages<'a>(messages: &'a [MessageInfo]) -> Vec<MessageGroup<'a>> {
+    let mut result = Vec::new();
+    let mut last_day: Option<i64> = None;
+    let mut last_sender: Option<(bool, String)> = None; // (is_outgoing, sender_name)
+    let mut album_acc: Vec<&MessageInfo> = Vec::new();
+
+    /// Сбрасывает аккумулятор альбома в результат
+    fn flush_album<'a>(acc: &mut Vec<&'a MessageInfo>, result: &mut Vec<MessageGroup<'a>>) {
+        if acc.is_empty() {
+            return;
+        }
+        if acc.len() >= 2 {
+            result.push(MessageGroup::Album(std::mem::take(acc)));
+        } else {
+            // Одно сообщение — не альбом
+            result.push(MessageGroup::Message(acc.remove(0)));
+        }
+    }
+
+    for msg in messages {
+        // Проверяем, нужно ли добавить разделитель даты
+        let msg_day = get_day(msg.date());
+
+        if last_day != Some(msg_day) {
+            // Flush аккумулятор перед разделителем даты
+            flush_album(&mut album_acc, &mut result);
+            // Добавляем разделитель даты
+            result.push(MessageGroup::DateSeparator(msg.date()));
+            last_day = Some(msg_day);
+            last_sender = None; // Сбрасываем отправителя при смене дня
+        }
+
+        let sender_name = if msg.is_outgoing() {
+            "Вы".to_string()
+        } else {
+            msg.sender_name().to_string()
+        };
+
+        let current_sender = (msg.is_outgoing(), sender_name.clone());
+
+        // Проверяем, нужно ли показать заголовок отправителя
+        let show_sender_header = last_sender.as_ref() != Some(&current_sender);
+
+        if show_sender_header {
+            // Flush аккумулятор перед сменой отправителя
+            flush_album(&mut album_acc, &mut result);
+            result.push(MessageGroup::SenderHeader { is_outgoing: msg.is_outgoing(), sender_name });
+            last_sender = Some(current_sender);
+        }
+
+        // Проверяем, является ли сообщение частью альбома
+        let album_id = msg.media_album_id();
+        if album_id != 0 {
+            // Проверяем, совпадает ли album_id с текущим аккумулятором
+            if let Some(first) = album_acc.first() {
+                if first.media_album_id() == album_id {
+                    // Тот же альбом — добавляем
+                    album_acc.push(msg);
+                    continue;
+                } else {
+                    // Другой альбом — flush старый, начинаем новый
+                    flush_album(&mut album_acc, &mut result);
+                    album_acc.push(msg);
+                    continue;
+                }
+            } else {
+                // Аккумулятор пуст — начинаем новый альбом
+                album_acc.push(msg);
+                continue;
+            }
+        }
+
+        // Обычное сообщение (не альбом) — flush аккумулятор
+        flush_album(&mut album_acc, &mut result);
+        result.push(MessageGroup::Message(msg));
+    }
+
+    // Flush оставшийся аккумулятор
+    flush_album(&mut album_acc, &mut result);
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tdlib::types::MessageBuilder;
+    use crate::types::MessageId;
+
+    #[test]
+    fn test_group_messages_by_date() {
+        // Создаём сообщения с разными датами
+        let msg1 = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Message 1")
+            .date(1609459200) // 2021-01-01 00:00:00 UTC
+            .incoming()
+            .build();
+
+        let msg2 = MessageBuilder::new(MessageId::new(2))
+            .sender_name("Alice")
+            .text("Message 2")
+            .date(1609545600) // 2021-01-02 00:00:00 UTC
+            .incoming()
+            .build();
+
+        let messages = vec![msg1, msg2];
+        let grouped = group_messages(&messages);
+
+        // Должно быть: DateSep, SenderHeader, Message, DateSep, SenderHeader, Message
+        assert_eq!(grouped.len(), 6);
+
+        assert!(matches!(grouped[0], MessageGroup::DateSeparator(_)));
+        assert!(matches!(grouped[1], MessageGroup::SenderHeader { .. }));
+        assert!(matches!(grouped[2], MessageGroup::Message(_)));
+        assert!(matches!(grouped[3], MessageGroup::DateSeparator(_)));
+        assert!(matches!(grouped[4], MessageGroup::SenderHeader { .. }));
+        assert!(matches!(grouped[5], MessageGroup::Message(_)));
+    }
+
+    #[test]
+    fn test_group_messages_by_sender() {
+        // Создаём сообщения от разных отправителей
+        let msg1 = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Message 1")
+            .date(1609459200)
+            .incoming()
+            .build();
+
+        let msg2 = MessageBuilder::new(MessageId::new(2))
+            .sender_name("Alice")
+            .text("Message 2")
+            .date(1609459300) // +100 секунд, тот же день
+            .incoming()
+            .build();
+
+        let msg3 = MessageBuilder::new(MessageId::new(3))
+            .sender_name("Bob")
+            .text("Message 3")
+            .date(1609459400)
+            .incoming()
+            .build();
+
+        let messages = vec![msg1, msg2, msg3];
+        let grouped = group_messages(&messages);
+
+        // Должно быть: DateSep, SenderHeader(Alice), Message, Message, SenderHeader(Bob), Message
+        assert_eq!(grouped.len(), 6);
+
+        assert!(matches!(grouped[0], MessageGroup::DateSeparator(_)));
+
+        if let MessageGroup::SenderHeader { sender_name, .. } = &grouped[1] {
+            assert_eq!(sender_name, "Alice");
+        } else {
+            panic!("Expected SenderHeader");
+        }
+
+        assert!(matches!(grouped[2], MessageGroup::Message(_)));
+        assert!(matches!(grouped[3], MessageGroup::Message(_)));
+
+        if let MessageGroup::SenderHeader { sender_name, .. } = &grouped[4] {
+            assert_eq!(sender_name, "Bob");
+        } else {
+            panic!("Expected SenderHeader");
+        }
+
+        assert!(matches!(grouped[5], MessageGroup::Message(_)));
+    }
+
+    #[test]
+    fn test_group_outgoing_vs_incoming() {
+        // Проверяем группировку исходящих и входящих сообщений
+        let msg1 = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Hello")
+            .date(1609459200)
+            .incoming()
+            .build();
+
+        let msg2 = MessageBuilder::new(MessageId::new(2))
+            .sender_name("Me")
+            .text("Hi")
+            .date(1609459300)
+            .outgoing()
+            .build();
+
+        let messages = vec![msg1, msg2];
+        let grouped = group_messages(&messages);
+
+        // Должно быть: DateSep, SenderHeader(Alice), Message, SenderHeader(Me), Message
+        assert_eq!(grouped.len(), 5);
+
+        if let MessageGroup::SenderHeader { is_outgoing, sender_name } = &grouped[1] {
+            assert!(!*is_outgoing);
+            assert_eq!(sender_name, "Alice");
+        } else {
+            panic!("Expected SenderHeader");
+        }
+
+        if let MessageGroup::SenderHeader { is_outgoing, sender_name } = &grouped[3] {
+            assert!(*is_outgoing);
+            assert_eq!(sender_name, "Вы");
+        } else {
+            panic!("Expected SenderHeader");
+        }
+    }
+
+    #[test]
+    fn test_empty_messages() {
+        let messages: Vec<MessageInfo> = vec![];
+        let grouped = group_messages(&messages);
+        assert_eq!(grouped.len(), 0);
+    }
+
+    #[test]
+    fn test_single_message() {
+        let msg = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Single message")
+            .date(1609459200)
+            .incoming()
+            .build();
+
+        let messages = vec![msg];
+        let grouped = group_messages(&messages);
+
+        // Должно быть: DateSep, SenderHeader, Message
+        assert_eq!(grouped.len(), 3);
+        assert!(matches!(grouped[0], MessageGroup::DateSeparator(_)));
+        assert!(matches!(grouped[1], MessageGroup::SenderHeader { .. }));
+        assert!(matches!(grouped[2], MessageGroup::Message(_)));
+    }
+
+    #[test]
+    fn test_album_grouping_two_photos() {
+        let msg1 = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Photo 1")
+            .date(1609459200)
+            .incoming()
+            .media_album_id(12345)
+            .build();
+
+        let msg2 = MessageBuilder::new(MessageId::new(2))
+            .sender_name("Alice")
+            .text("Photo 2")
+            .date(1609459201)
+            .incoming()
+            .media_album_id(12345)
+            .build();
+
+        let messages = vec![msg1, msg2];
+        let grouped = group_messages(&messages);
+
+        // DateSep, SenderHeader, Album
+        assert_eq!(grouped.len(), 3);
+        assert!(matches!(grouped[0], MessageGroup::DateSeparator(_)));
+        assert!(matches!(grouped[1], MessageGroup::SenderHeader { .. }));
+        if let MessageGroup::Album(album) = &grouped[2] {
+            assert_eq!(album.len(), 2);
+            assert_eq!(album[0].id(), MessageId::new(1));
+            assert_eq!(album[1].id(), MessageId::new(2));
+        } else {
+            panic!("Expected Album, got {:?}", grouped[2]);
+        }
+    }
+
+    #[test]
+    fn test_album_single_photo_not_album() {
+        // Одно сообщение с album_id → не альбом, обычное сообщение
+        let msg = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Single photo")
+            .date(1609459200)
+            .incoming()
+            .media_album_id(12345)
+            .build();
+
+        let messages = vec![msg];
+        let grouped = group_messages(&messages);
+
+        // DateSep, SenderHeader, Message (не Album)
+        assert_eq!(grouped.len(), 3);
+        assert!(matches!(grouped[2], MessageGroup::Message(_)));
+    }
+
+    #[test]
+    fn test_album_with_regular_messages() {
+        let msg1 = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Text message")
+            .date(1609459200)
+            .incoming()
+            .build();
+
+        let msg2 = MessageBuilder::new(MessageId::new(2))
+            .sender_name("Alice")
+            .text("Photo 1")
+            .date(1609459201)
+            .incoming()
+            .media_album_id(100)
+            .build();
+
+        let msg3 = MessageBuilder::new(MessageId::new(3))
+            .sender_name("Alice")
+            .text("Photo 2")
+            .date(1609459202)
+            .incoming()
+            .media_album_id(100)
+            .build();
+
+        let msg4 = MessageBuilder::new(MessageId::new(4))
+            .sender_name("Alice")
+            .text("After album")
+            .date(1609459203)
+            .incoming()
+            .build();
+
+        let messages = vec![msg1, msg2, msg3, msg4];
+        let grouped = group_messages(&messages);
+
+        // DateSep, SenderHeader, Message, Album, Message
+        assert_eq!(grouped.len(), 5);
+        assert!(matches!(grouped[2], MessageGroup::Message(_)));
+        assert!(matches!(grouped[3], MessageGroup::Album(_)));
+        assert!(matches!(grouped[4], MessageGroup::Message(_)));
+    }
+
+    #[test]
+    fn test_two_different_albums() {
+        let msg1 = MessageBuilder::new(MessageId::new(1))
+            .sender_name("Alice")
+            .text("Album 1 - Photo 1")
+            .date(1609459200)
+            .incoming()
+            .media_album_id(100)
+            .build();
+
+        let msg2 = MessageBuilder::new(MessageId::new(2))
+            .sender_name("Alice")
+            .text("Album 1 - Photo 2")
+            .date(1609459201)
+            .incoming()
+            .media_album_id(100)
+            .build();
+
+        let msg3 = MessageBuilder::new(MessageId::new(3))
+            .sender_name("Alice")
+            .text("Album 2 - Photo 1")
+            .date(1609459202)
+            .incoming()
+            .media_album_id(200)
+            .build();
+
+        let msg4 = MessageBuilder::new(MessageId::new(4))
+            .sender_name("Alice")
+            .text("Album 2 - Photo 2")
+            .date(1609459203)
+            .incoming()
+            .media_album_id(200)
+            .build();
+
+        let messages = vec![msg1, msg2, msg3, msg4];
+        let grouped = group_messages(&messages);
+
+        // DateSep, SenderHeader, Album(2), Album(2)
+        assert_eq!(grouped.len(), 4);
+        if let MessageGroup::Album(a1) = &grouped[2] {
+            assert_eq!(a1.len(), 2);
+            assert_eq!(a1[0].media_album_id(), 100);
+        } else {
+            panic!("Expected first Album");
+        }
+        if let MessageGroup::Album(a2) = &grouped[3] {
+            assert_eq!(a2.len(), 2);
+            assert_eq!(a2[0].media_album_id(), 200);
+        } else {
+            panic!("Expected second Album");
+        }
+    }
+}

crates/tele-core/src/tdlib/auth.rs

@@ -0,0 +1,215 @@
+use tdlib_rs::enums::{AuthorizationState, Update};
+use tdlib_rs::functions;
+
+/// Состояние процесса авторизации в Telegram.
+///
+/// Отслеживает текущий этап аутентификации пользователя,
+/// от инициализации TDLib до полной авторизации.
+#[allow(dead_code)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum AuthState {
+    /// Ожидание параметров TDLib (начальное состояние).
+    WaitTdlibParameters,
+
+    /// Ожидание ввода номера телефона.
+    WaitPhoneNumber,
+
+    /// Ожидание ввода кода подтверждения из SMS/Telegram.
+    WaitCode,
+
+    /// Ожидание ввода пароля двухфакторной аутентификации (2FA).
+    WaitPassword,
+
+    /// Авторизация завершена, клиент готов к работе.
+    Ready,
+
+    /// Соединение закрыто.
+    Closed,
+
+    /// Произошла ошибка авторизации.
+    Error(String),
+}
+
+/// Менеджер авторизации TDLib.
+///
+/// Управляет процессом авторизации пользователя в Telegram,
+/// отслеживает текущее состояние и предоставляет методы
+/// для отправки учетных данных (номер телефона, код, пароль).
+///
+/// # Процесс авторизации
+///
+/// 1. `WaitTdlibParameters` → автоматически
+/// 2. `WaitPhoneNumber` → [`send_phone_number()`](Self::send_phone_number)
+/// 3. `WaitCode` → [`send_code()`](Self::send_code)
+/// 4. `WaitPassword` (опционально) → [`send_password()`](Self::send_password)
+/// 5. `Ready` → авторизация завершена
+///
+/// # Examples
+///
+/// ```ignore
+/// let mut auth_manager = AuthManager::new(client_id);
+///
+/// // Отправляем номер телефона
+/// auth_manager.send_phone_number("+1234567890".to_string()).await?;
+///
+/// // После получения кода из SMS
+/// auth_manager.send_code("12345".to_string()).await?;
+///
+/// // Если включена 2FA
+/// if auth_manager.state == AuthState::WaitPassword {
+///     auth_manager.send_password("my_password".to_string()).await?;
+/// }
+///
+/// // Проверяем авторизацию
+/// if auth_manager.is_authenticated() {
+///     println!("Successfully authenticated!");
+/// }
+/// ```
+pub struct AuthManager {
+    /// Текущее состояние авторизации.
+    pub state: AuthState,
+
+    /// ID клиента TDLib для API вызовов.
+    client_id: i32,
+}
+
+#[allow(dead_code)]
+impl AuthManager {
+    /// Создает новый менеджер авторизации.
+    ///
+    /// # Arguments
+    ///
+    /// * `client_id` - ID клиента TDLib для API вызовов
+    ///
+    /// # Returns
+    ///
+    /// Новый экземпляр `AuthManager` в состоянии `WaitTdlibParameters`.
+    pub fn new(client_id: i32) -> Self {
+        Self { state: AuthState::WaitTdlibParameters, client_id }
+    }
+
+    /// Проверяет, завершена ли авторизация.
+    ///
+    /// # Returns
+    ///
+    /// `true` если состояние равно `AuthState::Ready`, иначе `false`.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// if auth_manager.is_authenticated() {
+    ///     println!("User is authenticated");
+    /// }
+    /// ```
+    pub fn is_authenticated(&self) -> bool {
+        self.state == AuthState::Ready
+    }
+
+    /// Обрабатывает обновление состояния авторизации от TDLib.
+    ///
+    /// Автоматически обновляет внутреннее состояние [`AuthState`] на основе
+    /// полученного update от TDLib.
+    ///
+    /// # Arguments
+    ///
+    /// * `update` - Обновление от TDLib (проверяется на `Update::AuthorizationState`)
+    ///
+    /// # Note
+    ///
+    /// Этот метод должен вызываться для каждого update от TDLib,
+    /// чтобы состояние авторизации оставалось актуальным.
+    pub fn handle_auth_update(&mut self, update: &Update) {
+        if let Update::AuthorizationState(auth_update) = update {
+            self.state = match &auth_update.authorization_state {
+                AuthorizationState::WaitTdlibParameters => AuthState::WaitTdlibParameters,
+                AuthorizationState::WaitPhoneNumber => AuthState::WaitPhoneNumber,
+                AuthorizationState::WaitCode(_) => AuthState::WaitCode,
+                AuthorizationState::WaitPassword(_) => AuthState::WaitPassword,
+                AuthorizationState::Ready => AuthState::Ready,
+                AuthorizationState::Closed => AuthState::Closed,
+                _ => return,
+            };
+        }
+    }
+
+    /// Отправляет номер телефона для авторизации.
+    ///
+    /// Используется на этапе [`AuthState::WaitPhoneNumber`].
+    /// После успешной отправки состояние изменится на `WaitCode`.
+    ///
+    /// # Arguments
+    ///
+    /// * `phone` - Номер телефона в международном формате (например, "+1234567890")
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Номер телефона принят, ожидайте SMS с кодом
+    /// * `Err(String)` - Ошибка (неверный формат, проблемы с сетью и т.д.)
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// auth_manager.send_phone_number("+1234567890".to_string()).await?;
+    /// ```
+    pub async fn send_phone_number(&self, phone: String) -> Result<(), String> {
+        functions::set_authentication_phone_number(phone, None, self.client_id)
+            .await
+            .map(|_| ())
+            .map_err(|e| format!("Ошибка отправки номера: {:?}", e))
+    }
+
+    /// Отправляет код подтверждения из SMS или Telegram.
+    ///
+    /// Используется на этапе [`AuthState::WaitCode`].
+    /// После успешной проверки состояние изменится на `Ready` или `WaitPassword`
+    /// (если включена двухфакторная аутентификация).
+    ///
+    /// # Arguments
+    ///
+    /// * `code` - Код подтверждения (обычно 5 цифр)
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Код верный
+    /// * `Err(String)` - Неверный код или истек срок действия
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// auth_manager.send_code("12345".to_string()).await?;
+    /// ```
+    pub async fn send_code(&self, code: String) -> Result<(), String> {
+        functions::check_authentication_code(code, self.client_id)
+            .await
+            .map(|_| ())
+            .map_err(|e| format!("Ошибка проверки кода: {:?}", e))
+    }
+
+    /// Отправляет пароль двухфакторной аутентификации (2FA).
+    ///
+    /// Используется на этапе [`AuthState::WaitPassword`] (только если 2FA включена).
+    /// После успешной проверки состояние изменится на `Ready`.
+    ///
+    /// # Arguments
+    ///
+    /// * `password` - Пароль двухфакторной аутентификации
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Пароль верный, авторизация завершена
+    /// * `Err(String)` - Неверный пароль
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// if auth_manager.state == AuthState::WaitPassword {
+    ///     auth_manager.send_password("my_2fa_password".to_string()).await?;
+    /// }
+    /// ```
+    pub async fn send_password(&self, password: String) -> Result<(), String> {
+        functions::check_authentication_password(password, self.client_id)
+            .await
+            .map(|_| ())
+            .map_err(|e| format!("Ошибка проверки пароля: {:?}", e))
+    }
+}

crates/tele-core/src/tdlib/chat_helpers.rs

@@ -0,0 +1,136 @@
+//! Chat management helper functions.
+//!
+//! This module contains utility functions for managing chats,
+//! including finding, updating, and adding/removing chats.
+
+use crate::constants::{MAX_CHATS, MAX_CHAT_USER_IDS};
+use crate::types::{ChatId, MessageId, UserId};
+use tdlib_rs::enums::{Chat as TdChat, ChatList, ChatType};
+
+use super::client::TdClient;
+use super::types::ChatInfo;
+
+/// Обновляет поле чата, если чат найден.
+pub fn update_chat<F>(client: &mut TdClient, chat_id: ChatId, updater: F)
+where
+    F: FnOnce(&mut ChatInfo),
+{
+    client.update_chat(chat_id, updater);
+}
+
+/// Добавляет новый чат или обновляет существующий
+pub fn add_or_update_chat(client: &mut TdClient, td_chat_enum: &TdChat) {
+    // Pattern match to get inner Chat struct
+    let TdChat::Chat(td_chat) = td_chat_enum;
+
+    // Пропускаем удалённые аккаунты
+    if td_chat.title == "Deleted Account" || td_chat.title.is_empty() {
+        // Удаляем из списка если уже был добавлен
+        client.remove_chat(ChatId::new(td_chat.id));
+        return;
+    }
+
+    // Ищем позицию в Main списке (если есть)
+    let main_position = td_chat
+        .positions
+        .iter()
+        .find(|pos| matches!(pos.list, ChatList::Main));
+
+    // Получаем order и is_pinned из позиции, или используем значения по умолчанию
+    let (order, is_pinned) = main_position
+        .map(|p| (p.order, p.is_pinned))
+        .unwrap_or((1, false)); // order=1 чтобы чат отображался
+
+    let (last_message, last_message_date) = td_chat
+        .last_message
+        .as_ref()
+        .map(|m| (TdClient::extract_message_text_static(m).0, m.date))
+        .unwrap_or_default();
+
+    // Извлекаем user_id для приватных чатов и сохраняем связь
+    let username = match &td_chat.r#type {
+        ChatType::Private(private) => {
+            // Ограничиваем размер chat_user_ids
+            let chat_id = ChatId::new(td_chat.id);
+            let user_id = UserId::new(private.user_id);
+            client.update_user_cache(|cache| {
+                if cache.chat_user_ids.len() >= MAX_CHAT_USER_IDS
+                    && !cache.chat_user_ids.contains_key(&chat_id)
+                {
+                    // Удаляем случайную запись (первую найденную)
+                    if let Some(&key) = cache.chat_user_ids.keys().next() {
+                        cache.chat_user_ids.remove(&key);
+                    }
+                }
+                cache.chat_user_ids.insert(chat_id, user_id);
+                // Проверяем, есть ли уже username в кэше (peek не обновляет LRU)
+                cache
+                    .user_usernames
+                    .peek(&user_id)
+                    .map(|u| format!("@{}", u))
+            })
+        }
+        _ => None,
+    };
+
+    // Извлекаем ID папок из позиций
+    let folder_ids: Vec<i32> = td_chat
+        .positions
+        .iter()
+        .filter_map(|pos| match &pos.list {
+            ChatList::Folder(folder) => Some(folder.chat_folder_id),
+            _ => None,
+        })
+        .collect();
+
+    // Проверяем mute статус
+    let is_muted = td_chat.notification_settings.mute_for > 0;
+
+    let chat_info = ChatInfo {
+        id: ChatId::new(td_chat.id),
+        title: td_chat.title.clone(),
+        username,
+        last_message,
+        last_message_date,
+        unread_count: td_chat.unread_count,
+        unread_mention_count: td_chat.unread_mention_count,
+        is_pinned,
+        order,
+        last_read_outbox_message_id: MessageId::new(td_chat.last_read_outbox_message_id),
+        folder_ids,
+        is_muted,
+        draft_text: None,
+    };
+
+    let chat_info_for_update = chat_info.clone();
+    let updated_existing = client.update_chat(ChatId::new(td_chat.id), |existing| {
+        existing.title = chat_info_for_update.title;
+        existing.last_message = chat_info_for_update.last_message;
+        existing.last_message_date = chat_info_for_update.last_message_date;
+        existing.unread_count = chat_info_for_update.unread_count;
+        existing.unread_mention_count = chat_info_for_update.unread_mention_count;
+        existing.last_read_outbox_message_id = chat_info_for_update.last_read_outbox_message_id;
+        existing.folder_ids = chat_info_for_update.folder_ids;
+        existing.is_muted = chat_info_for_update.is_muted;
+
+        // Обновляем username если он появился
+        if let Some(username) = chat_info_for_update.username {
+            existing.username = Some(username);
+        }
+
+        // Обновляем позицию только если она пришла
+        if main_position.is_some() {
+            existing.is_pinned = chat_info_for_update.is_pinned;
+            existing.order = chat_info_for_update.order;
+        }
+    });
+
+    if !updated_existing {
+        client.push_chat(chat_info);
+        // Ограничиваем количество чатов
+        client.trim_chats_to_max_by_order(MAX_CHATS);
+    }
+
+    // Сортируем чаты по order (TDLib order учитывает pinned и время)
+    client.sort_chats_by_order();
+}

crates/tele-core/src/tdlib/chats.rs

@@ -0,0 +1,380 @@
+use crate::types::{ChatId, UserId};
+use std::time::Instant;
+use tdlib_rs::enums::{ChatAction, ChatList, ChatType};
+use tdlib_rs::functions;
+
+use super::types::{ChatInfo, FolderInfo, ProfileInfo};
+
+/// Менеджер чатов TDLib.
+///
+/// Управляет списком чатов, папками, информацией о профилях
+/// и typing-статусом собеседников.
+///
+/// # Основные возможности
+///
+/// - Загрузка чатов из главного списка и папок
+/// - Получение информации о профиле чата/пользователя
+/// - Отправка typing-индикатора ("печатает...")
+/// - Отслеживание typing-статуса собеседников
+/// - Выход из чатов/групп
+///
+/// # Examples
+///
+/// ```ignore
+/// let mut chat_manager = ChatManager::new(client_id);
+///
+/// // Загружаем чаты
+/// chat_manager.load_chats(50).await?;
+///
+/// // Получаем информацию о профиле
+/// let profile = chat_manager.get_profile_info(chat_id).await?;
+/// println!("Bio: {}", profile.bio.unwrap_or_default());
+/// ```
+pub struct ChatManager {
+    /// Список загруженных чатов.
+    pub chats: Vec<ChatInfo>,
+
+    /// Список папок чатов.
+    pub folders: Vec<FolderInfo>,
+
+    /// Позиция в главном списке чатов для пагинации.
+    pub main_chat_list_position: i32,
+
+    /// Typing status для текущего чата: (user_id, action_text, timestamp).
+    pub typing_status: Option<(UserId, String, Instant)>,
+
+    /// ID клиента TDLib для API вызовов.
+    client_id: i32,
+}
+
+impl ChatManager {
+    /// Создает новый менеджер чатов.
+    ///
+    /// # Arguments
+    ///
+    /// * `client_id` - ID клиента TDLib для API вызовов
+    ///
+    /// # Returns
+    ///
+    /// Новый экземпляр `ChatManager` с пустым списком чатов.
+    pub fn new(client_id: i32) -> Self {
+        Self {
+            chats: Vec::new(),
+            folders: Vec::new(),
+            main_chat_list_position: 0,
+            typing_status: None,
+            client_id,
+        }
+    }
+
+    /// Загружает чаты из главного списка.
+    ///
+    /// Запрашивает у TDLib чаты из основного списка (исключая архив).
+    /// После вызова чаты будут доступны через updates от TDLib.
+    ///
+    /// # Arguments
+    ///
+    /// * `limit` - Максимальное количество чатов для загрузки
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Запрос отправлен, чаты будут загружены через updates
+    /// * `Err(String)` - Ошибка при отправке запроса
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// chat_manager.load_chats(50).await?;
+    /// ```
+    pub async fn load_chats(&mut self, limit: i32) -> Result<(), String> {
+        let result = functions::load_chats(Some(ChatList::Main), limit, self.client_id).await;
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(format!("Ошибка загрузки чатов: {:?}", e)),
+        }
+    }
+
+    /// Загружает чаты из указанной папки.
+    ///
+    /// # Arguments
+    ///
+    /// * `folder_id` - ID папки чатов
+    /// * `limit` - Максимальное количество чатов для загрузки
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Запрос отправлен
+    /// * `Err(String)` - Ошибка при отправке запроса
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // Загрузить чаты из папки с ID 1
+    /// chat_manager.load_folder_chats(1, 50).await?;
+    /// ```
+    pub async fn load_folder_chats(&mut self, folder_id: i32, limit: i32) -> Result<(), String> {
+        let chat_list =
+            ChatList::Folder(tdlib_rs::types::ChatListFolder { chat_folder_id: folder_id });
+
+        let result = functions::load_chats(Some(chat_list), limit, self.client_id).await;
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(format!("Ошибка загрузки папки: {:?}", e)),
+        }
+    }
+
+    /// Выходит из чата или группы.
+    ///
+    /// Для приватных чатов — удаляет историю, для групп — покидает группу.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата для выхода
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Успешный выход
+    /// * `Err(String)` - Ошибка (нет прав, чат не найден и т.д.)
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// chat_manager.leave_chat(ChatId::new(123456)).await?;
+    /// ```
+    pub async fn leave_chat(&self, chat_id: ChatId) -> Result<(), String> {
+        let result = functions::leave_chat(chat_id.as_i64(), self.client_id).await;
+        match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(format!("Ошибка выхода из чата: {:?}", e)),
+        }
+    }
+
+    /// Получает детальную информацию о профиле чата или пользователя.
+    ///
+    /// Загружает полную информацию включая bio, номер телефона, username,
+    /// статус онлайн (для личных чатов), количество участников и описание
+    /// (для групп/каналов).
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата для получения информации
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(ProfileInfo)` - Информация о профиле
+    /// * `Err(String)` - Ошибка получения данных
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// let profile = chat_manager.get_profile_info(ChatId::new(123)).await?;
+    /// println!("Title: {}", profile.title);
+    /// println!("Bio: {}", profile.bio.unwrap_or_default());
+    /// println!("Members: {}", profile.member_count.unwrap_or(0));
+    /// ```
+    pub async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String> {
+        // Получаем основную информацию о чате
+        let chat_result = functions::get_chat(chat_id.as_i64(), self.client_id).await;
+        let chat_enum = match chat_result {
+            Ok(c) => c,
+            Err(e) => return Err(format!("Ошибка получения чата: {:?}", e)),
+        };
+
+        let tdlib_rs::enums::Chat::Chat(chat) = chat_enum;
+
+        let chat_type_str = match &chat.r#type {
+            ChatType::Private(_) => "Личный чат",
+            ChatType::Supergroup(sg) => {
+                if sg.is_channel {
+                    "Канал"
+                } else {
+                    "Группа"
+                }
+            }
+            ChatType::BasicGroup(_) => "Группа",
+            ChatType::Secret(_) => "Секретный чат",
+        };
+
+        let is_group = matches!(&chat.r#type, ChatType::Supergroup(_) | ChatType::BasicGroup(_));
+
+        // Для личных чатов получаем информацию о пользователе
+        let (bio, phone_number, username, online_status) = if let ChatType::Private(private_chat) =
+            &chat.r#type
+        {
+            match functions::get_user(private_chat.user_id, self.client_id).await {
+                Ok(tdlib_rs::enums::User::User(user)) => {
+                    let bio_opt =
+                        if let Ok(tdlib_rs::enums::UserFullInfo::UserFullInfo(full_info)) =
+                            functions::get_user_full_info(private_chat.user_id, self.client_id)
+                                .await
+                        {
+                            full_info.bio.map(|b| b.text)
+                        } else {
+                            None
+                        };
+
+                    let online_status_str = match user.status {
+                        tdlib_rs::enums::UserStatus::Online(_) => Some("В сети".to_string()),
+                        tdlib_rs::enums::UserStatus::Recently(_) => {
+                            Some("Был(а) недавно".to_string())
+                        }
+                        tdlib_rs::enums::UserStatus::LastWeek(_) => {
+                            Some("Был(а) на этой неделе".to_string())
+                        }
+                        tdlib_rs::enums::UserStatus::LastMonth(_) => {
+                            Some("Был(а) в этом месяце".to_string())
+                        }
+                        tdlib_rs::enums::UserStatus::Offline(s) => {
+                            // Форматируем время последнего визита
+                            Some(format!("Был(а) в сети {}", s.was_online))
+                        }
+                        _ => None,
+                    };
+
+                    let username_opt = user.usernames.as_ref().map(|u| u.editable_username.clone());
+
+                    (bio_opt, Some(user.phone_number.clone()), username_opt, online_status_str)
+                }
+                _ => (None, None, None, None),
+            }
+        } else {
+            (None, None, None, None)
+        };
+
+        // Для групп/каналов получаем полную информацию
+        let (member_count, description, invite_link) = if is_group {
+            if let ChatType::Supergroup(sg) = &chat.r#type {
+                match functions::get_supergroup_full_info(sg.supergroup_id, self.client_id).await {
+                    Ok(tdlib_rs::enums::SupergroupFullInfo::SupergroupFullInfo(full_info)) => {
+                        let desc = if !full_info.description.is_empty() {
+                            Some(full_info.description.clone())
+                        } else {
+                            None
+                        };
+                        let link = full_info
+                            .invite_link
+                            .as_ref()
+                            .map(|l| l.invite_link.clone());
+                        (Some(full_info.member_count), desc, link)
+                    }
+                    _ => (None, None, None),
+                }
+            } else if let ChatType::BasicGroup(bg) = &chat.r#type {
+                match functions::get_basic_group_full_info(bg.basic_group_id, self.client_id).await
+                {
+                    Ok(tdlib_rs::enums::BasicGroupFullInfo::BasicGroupFullInfo(full_info)) => {
+                        let desc = if !full_info.description.is_empty() {
+                            Some(full_info.description.clone())
+                        } else {
+                            None
+                        };
+                        let link = full_info.invite_link.map(|l| l.invite_link);
+                        (Some(full_info.members.len() as i32), desc, link)
+                    }
+                    Err(_) => (None, None, None),
+                }
+            } else {
+                (None, None, None)
+            }
+        } else {
+            (None, None, None)
+        };
+
+        Ok(ProfileInfo {
+            chat_id,
+            title: chat.title,
+            username,
+            bio,
+            phone_number,
+            chat_type: chat_type_str.to_string(),
+            member_count,
+            description,
+            invite_link,
+            is_group,
+            online_status,
+        })
+    }
+
+    /// Отправляет typing-действие в чат.
+    ///
+    /// Показывает собеседнику индикатор "печатает..." или другой статус активности.
+    /// Действие автоматически сбрасывается через 5 секунд.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `action` - Тип действия (Typing, RecordingVideo, UploadingPhoto и т.д.)
+    ///
+    /// # Note
+    ///
+    /// Этот метод нужно вызывать периодически (каждые 5 секунд) пока действие активно.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use tdlib_rs::enums::ChatAction;
+    ///
+    /// // Показать индикатор "печатает..."
+    /// chat_manager.send_chat_action(
+    ///     chat_id,
+    ///     ChatAction::Typing
+    /// ).await;
+    /// ```
+    pub async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        let _ =
+            functions::send_chat_action(chat_id.as_i64(), 0, Some(action), self.client_id).await;
+    }
+
+    /// Очищает устаревший typing-статус.
+    ///
+    /// Удаляет typing-статус если прошло более 5 секунд с момента последнего обновления.
+    /// Вызывайте этот метод периодически (например, каждый тик UI) для своевременной
+    /// очистки индикатора "печатает...".
+    ///
+    /// # Returns
+    ///
+    /// * `true` - Если статус был очищен
+    /// * `false` - Если статус актуален или его не было
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // В основном цикле UI
+    /// if chat_manager.clear_stale_typing_status() {
+    ///     // Перерисовать UI чтобы убрать индикатор "печатает..."
+    ///     needs_redraw = true;
+    /// }
+    /// ```
+    pub fn clear_stale_typing_status(&mut self) -> bool {
+        if let Some((_, _, timestamp)) = self.typing_status {
+            if timestamp.elapsed().as_secs() > 5 {
+                self.typing_status = None;
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Получает текст typing-индикатора для отображения.
+    ///
+    /// # Returns
+    ///
+    /// * `Some(String)` - Текст действия (например, "печатает...", "записывает видео...")
+    /// * `None` - Нет активного typing-статуса
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// if let Some(typing_text) = chat_manager.get_typing_text() {
+    ///     println!("Status: {}", typing_text);
+    /// }
+    /// ```
+    #[allow(dead_code)]
+    pub fn get_typing_text(&self) -> Option<String> {
+        self.typing_status
+            .as_ref()
+            .map(|(_, action, _)| action.clone())
+    }
+}

crates/tele-core/src/tdlib/client.rs

@@ -0,0 +1,848 @@
+use crate::types::{ChatId, MessageId, UserId};
+use std::collections::VecDeque;
+use std::path::PathBuf;
+use tdlib_rs::enums::{Chat as TdChat, ChatList, ConnectionState, Update, UserStatus};
+use tdlib_rs::functions;
+use tdlib_rs::types::Message as TdMessage;
+
+use super::auth::{AuthManager, AuthState};
+use super::chats::ChatManager;
+use super::messages::MessageManager;
+use super::reactions::ReactionManager;
+use super::types::{
+    ChatInfo, FolderInfo, MessageInfo, NetworkState, ProfileInfo, UserOnlineStatus,
+};
+use super::users::UserCache;
+
+#[derive(Debug, Clone)]
+pub struct TdCredentials {
+    pub api_id: i32,
+    pub api_hash: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct TdClientConfig {
+    pub credentials: TdCredentials,
+    pub db_path: PathBuf,
+}
+
+#[derive(Debug, Clone)]
+pub struct IncomingMessageEvent {
+    pub chat: ChatInfo,
+    pub message: MessageInfo,
+    pub sender_name: String,
+}
+
+/// TDLib client wrapper for Telegram integration.
+///
+/// Provides high-level API for authentication, chat management, messaging,
+/// and user caching. Delegates functionality to specialized managers:
+/// - `AuthManager` for authentication flow
+/// - `ChatManager` for chat operations
+/// - `MessageManager` for message operations
+/// - `UserCache` for user information caching
+/// - `ReactionManager` for message reactions
+///
+/// # Examples
+///
+/// ```ignore
+/// use tele_core::tdlib::TdClient;
+///
+/// let mut client = TdClient::new(tele_core::tdlib::TdClientConfig {
+///     credentials: tele_core::tdlib::TdCredentials {
+///         api_id: 123,
+///         api_hash: "hash".to_string(),
+///     },
+///     db_path: std::path::PathBuf::from("tdlib_data"),
+/// });
+///
+/// // Start authorization
+/// client.send_phone_number("+1234567890".to_string()).await?;
+/// client.send_code("12345".to_string()).await?;
+///
+/// // Load chats
+/// client.load_chats(50).await?;
+/// # Ok::<(), String>(())
+/// ```
+pub struct TdClient {
+    pub api_id: i32,
+    pub api_hash: String,
+    pub db_path: PathBuf,
+    client_id: i32,
+
+    // Менеджеры (делегируем им функциональность)
+    pub auth: AuthManager,
+    pub chat_manager: ChatManager,
+    pub message_manager: MessageManager,
+    pub user_cache: UserCache,
+    pub reaction_manager: ReactionManager,
+    incoming_message_events: VecDeque<IncomingMessageEvent>,
+
+    // Состояние сети
+    pub network_state: NetworkState,
+}
+
+#[allow(dead_code)]
+impl TdClient {
+    /// Creates a new TDLib client instance.
+    ///
+    /// Initializes all managers and sets initial network state to Connecting.
+    ///
+    /// # Returns
+    ///
+    /// A new `TdClient` instance ready for authentication.
+    pub fn new(config: TdClientConfig) -> Self {
+        let client_id = tdlib_rs::create_client();
+
+        Self {
+            api_id: config.credentials.api_id,
+            api_hash: config.credentials.api_hash,
+            db_path: config.db_path,
+            client_id,
+            auth: AuthManager::new(client_id),
+            chat_manager: ChatManager::new(client_id),
+            message_manager: MessageManager::new(client_id),
+            user_cache: UserCache::new(client_id),
+            reaction_manager: ReactionManager::new(client_id),
+            incoming_message_events: VecDeque::new(),
+            network_state: NetworkState::Connecting,
+        }
+    }
+
+    pub fn enqueue_incoming_message_event(
+        &mut self,
+        chat: ChatInfo,
+        message: MessageInfo,
+        sender_name: String,
+    ) {
+        self.incoming_message_events
+            .push_back(IncomingMessageEvent { chat, message, sender_name });
+    }
+
+    pub fn drain_incoming_message_events(&mut self) -> Vec<IncomingMessageEvent> {
+        self.incoming_message_events.drain(..).collect()
+    }
+
+    // Делегирование к auth
+
+    /// Sends phone number for authentication.
+    ///
+    /// This is the first step of the authentication flow.
+    ///
+    /// # Arguments
+    ///
+    /// * `phone` - Phone number in international format (e.g., "+1234567890")
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the phone number is invalid or network request fails.
+    pub async fn send_phone_number(&self, phone: String) -> Result<(), String> {
+        self.auth.send_phone_number(phone).await
+    }
+
+    /// Sends authentication code received via SMS.
+    ///
+    /// This is the second step of the authentication flow.
+    ///
+    /// # Arguments
+    ///
+    /// * `code` - Authentication code (typically 5 digits)
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the code is invalid or expired.
+    pub async fn send_code(&self, code: String) -> Result<(), String> {
+        self.auth.send_code(code).await
+    }
+
+    /// Sends 2FA password if required.
+    ///
+    /// This is the third step of the authentication flow (if 2FA is enabled).
+    ///
+    /// # Arguments
+    ///
+    /// * `password` - Two-factor authentication password
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the password is incorrect.
+    pub async fn send_password(&self, password: String) -> Result<(), String> {
+        self.auth.send_password(password).await
+    }
+
+    // Делегирование к chat_manager
+
+    /// Loads chats from the main chat list.
+    ///
+    /// Loads up to `limit` chats from ChatList::Main, excluding archived chats.
+    /// Filters out "Deleted Account" chats automatically.
+    ///
+    /// # Arguments
+    ///
+    /// * `limit` - Maximum number of chats to load (typically 50-200)
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the network request fails.
+    pub async fn load_chats(&mut self, limit: i32) -> Result<(), String> {
+        self.chat_manager.load_chats(limit).await
+    }
+
+    /// Loads chats from a specific folder.
+    ///
+    /// # Arguments
+    ///
+    /// * `folder_id` - Folder ID (1-9 for user folders)
+    /// * `limit` - Maximum number of chats to load
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the folder doesn't exist or network request fails.
+    pub async fn load_folder_chats(&mut self, folder_id: i32, limit: i32) -> Result<(), String> {
+        self.chat_manager.load_folder_chats(folder_id, limit).await
+    }
+
+    /// Leaves a group or channel.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID of the chat to leave
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the user is not a member or network request fails.
+    pub async fn leave_chat(&self, chat_id: ChatId) -> Result<(), String> {
+        self.chat_manager.leave_chat(chat_id).await
+    }
+
+    /// Gets profile information for a chat.
+    ///
+    /// Fetches detailed information including bio, username, member count, etc.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID of the chat
+    ///
+    /// # Returns
+    ///
+    /// `ProfileInfo` with chat details
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the chat doesn't exist or network request fails.
+    pub async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String> {
+        self.chat_manager.get_profile_info(chat_id).await
+    }
+
+    pub async fn send_chat_action(&self, chat_id: ChatId, action: tdlib_rs::enums::ChatAction) {
+        self.chat_manager.send_chat_action(chat_id, action).await
+    }
+
+    pub fn clear_stale_typing_status(&mut self) -> bool {
+        self.chat_manager.clear_stale_typing_status()
+    }
+
+    fn last_read_outbox_message_id(&self, chat_id: ChatId) -> MessageId {
+        self.chats()
+            .iter()
+            .find(|chat| chat.id == chat_id)
+            .map(|chat| chat.last_read_outbox_message_id)
+            .unwrap_or(MessageId::new(0))
+    }
+
+    // Делегирование к message_manager
+    pub async fn get_chat_history(
+        &mut self,
+        chat_id: ChatId,
+        limit: i32,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let last_read_outbox_message_id = self.last_read_outbox_message_id(chat_id);
+        self.message_manager
+            .get_chat_history(chat_id, limit, last_read_outbox_message_id)
+            .await
+    }
+
+    pub async fn load_older_messages(
+        &mut self,
+        chat_id: ChatId,
+        from_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let last_read_outbox_message_id = self.last_read_outbox_message_id(chat_id);
+        self.message_manager
+            .load_older_messages(chat_id, from_message_id, last_read_outbox_message_id)
+            .await
+    }
+
+    pub async fn get_pinned_messages(
+        &mut self,
+        chat_id: ChatId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let last_read_outbox_message_id = self.last_read_outbox_message_id(chat_id);
+        self.message_manager
+            .get_pinned_messages(chat_id, last_read_outbox_message_id)
+            .await
+    }
+
+    pub async fn load_current_pinned_message(&mut self, chat_id: ChatId) {
+        self.message_manager
+            .load_current_pinned_message(chat_id)
+            .await
+    }
+
+    pub async fn search_messages(
+        &self,
+        chat_id: ChatId,
+        query: &str,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let last_read_outbox_message_id = self.last_read_outbox_message_id(chat_id);
+        self.message_manager
+            .search_messages(chat_id, query, last_read_outbox_message_id)
+            .await
+    }
+
+    pub async fn send_message(
+        &self,
+        chat_id: ChatId,
+        text: String,
+        reply_to_message_id: Option<MessageId>,
+        reply_info: Option<super::types::ReplyInfo>,
+    ) -> Result<MessageInfo, String> {
+        let last_read_outbox_message_id = self.last_read_outbox_message_id(chat_id);
+        self.message_manager
+            .send_message(
+                chat_id,
+                text,
+                reply_to_message_id,
+                reply_info,
+                last_read_outbox_message_id,
+            )
+            .await
+    }
+
+    pub async fn edit_message(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        text: String,
+    ) -> Result<MessageInfo, String> {
+        let last_read_outbox_message_id = self.last_read_outbox_message_id(chat_id);
+        self.message_manager
+            .edit_message(chat_id, message_id, text, last_read_outbox_message_id)
+            .await
+    }
+
+    pub async fn delete_messages(
+        &self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String> {
+        self.message_manager
+            .delete_messages(chat_id, message_ids, revoke)
+            .await
+    }
+
+    pub async fn forward_messages(
+        &self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String> {
+        self.message_manager
+            .forward_messages(to_chat_id, from_chat_id, message_ids)
+            .await
+    }
+
+    pub async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String> {
+        self.message_manager.set_draft_message(chat_id, text).await
+    }
+
+    pub fn push_message(&mut self, msg: MessageInfo) {
+        self.message_manager.push_message(msg)
+    }
+
+    pub async fn fetch_missing_reply_info(&mut self) {
+        self.message_manager.fetch_missing_reply_info().await
+    }
+
+    pub async fn process_pending_view_messages(&mut self) {
+        self.message_manager.process_pending_view_messages().await
+    }
+
+    // Делегирование к user_cache
+    pub fn get_user_status_by_chat_id(&self, chat_id: ChatId) -> Option<&UserOnlineStatus> {
+        self.user_cache.get_status_by_chat_id(chat_id)
+    }
+
+    pub async fn process_pending_user_ids(&mut self) {
+        self.user_cache.process_pending_user_ids().await
+    }
+
+    // Делегирование к reaction_manager
+    pub async fn get_message_available_reactions(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+    ) -> Result<Vec<String>, String> {
+        self.reaction_manager
+            .get_message_available_reactions(chat_id, message_id)
+            .await
+    }
+
+    pub async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        emoji: String,
+    ) -> Result<(), String> {
+        self.reaction_manager
+            .toggle_reaction(chat_id, message_id, emoji)
+            .await
+    }
+
+    // Делегирование файловых операций
+
+    /// Скачивает файл по file_id и возвращает локальный путь.
+    pub async fn download_file(&self, file_id: i32) -> Result<String, String> {
+        match functions::download_file(file_id, 1, 0, 0, true, self.client_id).await {
+            Ok(tdlib_rs::enums::File::File(file)) => {
+                if file.local.is_downloading_completed && !file.local.path.is_empty() {
+                    Ok(file.local.path)
+                } else {
+                    Err("Файл не скачан".to_string())
+                }
+            }
+            Err(e) => Err(format!("Ошибка скачивания файла: {:?}", e)),
+        }
+    }
+
+    // Вспомогательные методы
+    pub fn client_id(&self) -> i32 {
+        self.client_id
+    }
+
+    pub async fn get_me(&self) -> Result<i64, String> {
+        match functions::get_me(self.client_id).await {
+            Ok(tdlib_rs::enums::User::User(user)) => Ok(user.id),
+            Err(e) => Err(format!("Ошибка получения текущего пользователя: {:?}", e)),
+        }
+    }
+
+    // Accessor methods для обратной совместимости
+    pub fn auth_state(&self) -> &AuthState {
+        &self.auth.state
+    }
+
+    pub fn chats(&self) -> &[ChatInfo] {
+        &self.chat_manager.chats
+    }
+
+    pub fn update_chats<F, R>(&mut self, updater: F) -> R
+    where
+        F: FnOnce(&mut Vec<ChatInfo>) -> R,
+    {
+        updater(&mut self.chat_manager.chats)
+    }
+
+    pub fn update_chat<F>(&mut self, chat_id: ChatId, updater: F) -> bool
+    where
+        F: FnOnce(&mut ChatInfo),
+    {
+        let Some(chat) = self.chat_manager.chats.iter_mut().find(|c| c.id == chat_id) else {
+            return false;
+        };
+
+        updater(chat);
+        true
+    }
+
+    pub fn remove_chat(&mut self, chat_id: ChatId) {
+        self.chat_manager.chats.retain(|c| c.id != chat_id);
+    }
+
+    pub fn push_chat(&mut self, chat: ChatInfo) {
+        self.chat_manager.chats.push(chat);
+    }
+
+    pub fn trim_chats_to_max_by_order(&mut self, max_chats: usize) {
+        if self.chat_manager.chats.len() <= max_chats {
+            return;
+        }
+
+        let Some(min_idx) = self
+            .chat_manager
+            .chats
+            .iter()
+            .enumerate()
+            .min_by_key(|(_, chat)| chat.order)
+            .map(|(idx, _)| idx)
+        else {
+            return;
+        };
+
+        self.chat_manager.chats.remove(min_idx);
+    }
+
+    pub fn sort_chats_by_order(&mut self) {
+        self.chat_manager
+            .chats
+            .sort_by(|a, b| b.order.cmp(&a.order));
+    }
+
+    pub fn folders(&self) -> &[FolderInfo] {
+        &self.chat_manager.folders
+    }
+
+    pub fn update_folders<F, R>(&mut self, updater: F) -> R
+    where
+        F: FnOnce(&mut Vec<FolderInfo>) -> R,
+    {
+        updater(&mut self.chat_manager.folders)
+    }
+
+    pub fn set_folders(&mut self, folders: Vec<FolderInfo>) {
+        self.chat_manager.folders = folders;
+    }
+
+    pub fn current_chat_messages(&self) -> &[MessageInfo] {
+        &self.message_manager.current_chat_messages
+    }
+
+    pub fn clear_current_chat_messages(&mut self) {
+        self.message_manager.current_chat_messages.clear();
+    }
+
+    pub fn set_current_chat_messages(&mut self, messages: Vec<MessageInfo>) {
+        self.message_manager.current_chat_messages = messages;
+    }
+
+    pub fn update_current_chat_messages<F, R>(&mut self, updater: F) -> R
+    where
+        F: FnOnce(&mut Vec<MessageInfo>) -> R,
+    {
+        updater(&mut self.message_manager.current_chat_messages)
+    }
+
+    pub fn update_current_chat_message<F>(&mut self, message_id: MessageId, updater: F) -> bool
+    where
+        F: FnOnce(&mut MessageInfo),
+    {
+        let Some(message) = self
+            .message_manager
+            .current_chat_messages
+            .iter_mut()
+            .find(|message| message.id() == message_id)
+        else {
+            return false;
+        };
+
+        updater(message);
+        true
+    }
+
+    pub fn replace_current_chat_message(
+        &mut self,
+        message_id: MessageId,
+        new_message: MessageInfo,
+    ) -> bool {
+        self.update_current_chat_message(message_id, |message| {
+            *message = new_message;
+        })
+    }
+
+    pub fn current_chat_id(&self) -> Option<ChatId> {
+        self.message_manager.current_chat_id
+    }
+
+    pub fn set_current_chat_id(&mut self, chat_id: Option<ChatId>) {
+        self.message_manager.current_chat_id = chat_id;
+    }
+
+    pub fn current_pinned_message(&self) -> Option<&MessageInfo> {
+        self.message_manager.current_pinned_message.as_ref()
+    }
+
+    pub fn set_current_pinned_message(&mut self, msg: Option<MessageInfo>) {
+        self.message_manager.current_pinned_message = msg;
+    }
+
+    pub fn typing_status(&self) -> Option<&(crate::types::UserId, String, std::time::Instant)> {
+        self.chat_manager.typing_status.as_ref()
+    }
+
+    pub fn set_typing_status(
+        &mut self,
+        status: Option<(crate::types::UserId, String, std::time::Instant)>,
+    ) {
+        self.chat_manager.typing_status = status;
+    }
+
+    pub fn pending_view_messages(&self) -> &[(crate::types::ChatId, Vec<crate::types::MessageId>)] {
+        &self.message_manager.pending_view_messages
+    }
+
+    pub fn enqueue_pending_view_messages(
+        &mut self,
+        chat_id: crate::types::ChatId,
+        message_ids: Vec<crate::types::MessageId>,
+    ) {
+        self.message_manager
+            .pending_view_messages
+            .push((chat_id, message_ids));
+    }
+
+    pub fn pending_user_ids(&self) -> &[crate::types::UserId] {
+        &self.user_cache.pending_user_ids
+    }
+
+    pub fn queue_pending_user_id(&mut self, user_id: crate::types::UserId) {
+        if !self.user_cache.pending_user_ids.contains(&user_id) {
+            self.user_cache.pending_user_ids.push(user_id);
+        }
+    }
+
+    pub fn main_chat_list_position(&self) -> i32 {
+        self.chat_manager.main_chat_list_position
+    }
+
+    pub fn set_main_chat_list_position(&mut self, position: i32) {
+        self.chat_manager.main_chat_list_position = position;
+    }
+
+    // User cache accessors
+    pub fn user_cache(&self) -> &UserCache {
+        &self.user_cache
+    }
+
+    pub fn update_user_cache<F, R>(&mut self, updater: F) -> R
+    where
+        F: FnOnce(&mut UserCache) -> R,
+    {
+        updater(&mut self.user_cache)
+    }
+
+    // ==================== Helper методы для упрощения обработки updates ====================
+
+    /// Обрабатываем одно обновление от TDLib
+    pub fn handle_update(&mut self, update: Update) {
+        match update {
+            Update::AuthorizationState(state) => {
+                crate::tdlib::update_handlers::handle_auth_state(self, state.authorization_state);
+            }
+            Update::NewChat(new_chat) => {
+                // new_chat.chat is already a Chat struct, wrap it in TdChat enum
+                let td_chat = TdChat::Chat(new_chat.chat.clone());
+                crate::tdlib::chat_helpers::add_or_update_chat(self, &td_chat);
+            }
+            Update::ChatLastMessage(update) => {
+                let chat_id = ChatId::new(update.chat_id);
+                let (last_message_text, last_message_date) = update
+                    .last_message
+                    .as_ref()
+                    .map(|msg| (Self::extract_message_text_static(msg).0, msg.date))
+                    .unwrap_or_default();
+
+                crate::tdlib::chat_helpers::update_chat(self, chat_id, |chat| {
+                    chat.last_message = last_message_text;
+                    chat.last_message_date = last_message_date;
+                });
+
+                // Обновляем позиции если они пришли
+                for pos in update
+                    .positions
+                    .iter()
+                    .filter(|p| matches!(p.list, ChatList::Main))
+                {
+                    crate::tdlib::chat_helpers::update_chat(self, chat_id, |chat| {
+                        chat.order = pos.order;
+                        chat.is_pinned = pos.is_pinned;
+                    });
+                }
+
+                // Пересортируем по order
+                self.sort_chats_by_order();
+            }
+            Update::ChatReadInbox(update) => {
+                crate::tdlib::chat_helpers::update_chat(
+                    self,
+                    ChatId::new(update.chat_id),
+                    |chat| {
+                        chat.unread_count = update.unread_count;
+                    },
+                );
+            }
+            Update::ChatUnreadMentionCount(update) => {
+                crate::tdlib::chat_helpers::update_chat(
+                    self,
+                    ChatId::new(update.chat_id),
+                    |chat| {
+                        chat.unread_mention_count = update.unread_mention_count;
+                    },
+                );
+            }
+            Update::ChatNotificationSettings(update) => {
+                crate::tdlib::chat_helpers::update_chat(
+                    self,
+                    ChatId::new(update.chat_id),
+                    |chat| {
+                        // mute_for > 0 означает что чат замьючен
+                        chat.is_muted = update.notification_settings.mute_for > 0;
+                    },
+                );
+            }
+            Update::ChatReadOutbox(update) => {
+                // Обновляем last_read_outbox_message_id когда собеседник прочитал сообщения
+                let last_read_msg_id = MessageId::new(update.last_read_outbox_message_id);
+                crate::tdlib::chat_helpers::update_chat(
+                    self,
+                    ChatId::new(update.chat_id),
+                    |chat| {
+                        chat.last_read_outbox_message_id = last_read_msg_id;
+                    },
+                );
+                // Если это текущий открытый чат — обновляем is_read у сообщений
+                if Some(ChatId::new(update.chat_id)) == self.current_chat_id() {
+                    self.update_current_chat_messages(|messages| {
+                        for msg in messages {
+                            if msg.is_outgoing() && msg.id() <= last_read_msg_id {
+                                msg.state.is_read = true;
+                            }
+                        }
+                    });
+                }
+            }
+            Update::ChatPosition(update) => {
+                crate::tdlib::update_handlers::handle_chat_position_update(self, update);
+            }
+            Update::NewMessage(new_msg) => {
+                crate::tdlib::update_handlers::handle_new_message_update(self, new_msg);
+            }
+            Update::User(update) => {
+                crate::tdlib::update_handlers::handle_user_update(self, update);
+            }
+            Update::ChatFolders(update) => {
+                // Обновляем список папок
+                self.set_folders(
+                    update
+                        .chat_folders
+                        .into_iter()
+                        .map(|f| FolderInfo { id: f.id, name: f.title })
+                        .collect(),
+                );
+                self.set_main_chat_list_position(update.main_chat_list_position);
+            }
+            Update::UserStatus(update) => {
+                // Обновляем онлайн-статус пользователя
+                let status = match update.status {
+                    UserStatus::Online(_) => UserOnlineStatus::Online,
+                    UserStatus::Offline(offline) => UserOnlineStatus::Offline(offline.was_online),
+                    UserStatus::Recently(_) => UserOnlineStatus::Recently,
+                    UserStatus::LastWeek(_) => UserOnlineStatus::LastWeek,
+                    UserStatus::LastMonth(_) => UserOnlineStatus::LastMonth,
+                    UserStatus::Empty => UserOnlineStatus::LongTimeAgo,
+                };
+                self.update_user_cache(|cache| {
+                    cache
+                        .user_statuses
+                        .insert(UserId::new(update.user_id), status);
+                });
+            }
+            Update::ConnectionState(update) => {
+                // Обновляем состояние сетевого соединения
+                self.network_state = match update.state {
+                    ConnectionState::WaitingForNetwork => NetworkState::WaitingForNetwork,
+                    ConnectionState::ConnectingToProxy => NetworkState::ConnectingToProxy,
+                    ConnectionState::Connecting => NetworkState::Connecting,
+                    ConnectionState::Updating => NetworkState::Updating,
+                    ConnectionState::Ready => NetworkState::Ready,
+                };
+            }
+            Update::ChatAction(update) => {
+                crate::tdlib::update_handlers::handle_chat_action_update(self, update);
+            }
+            Update::ChatDraftMessage(update) => {
+                crate::tdlib::update_handlers::handle_chat_draft_message_update(self, update);
+            }
+            Update::MessageInteractionInfo(update) => {
+                crate::tdlib::update_handlers::handle_message_interaction_info_update(self, update);
+            }
+            Update::MessageSendSucceeded(update) => {
+                crate::tdlib::update_handlers::handle_message_send_succeeded_update(self, update);
+            }
+            _ => {}
+        }
+    }
+
+    // Helper functions
+    pub fn extract_message_text_static(
+        message: &TdMessage,
+    ) -> (String, Vec<tdlib_rs::types::TextEntity>) {
+        use tdlib_rs::enums::MessageContent;
+        match &message.content {
+            MessageContent::MessageText(text) => {
+                (text.text.text.clone(), text.text.entities.clone())
+            }
+            _ => (String::new(), Vec::new()),
+        }
+    }
+
+    /// Recreates the TDLib client with a new database path.
+    ///
+    /// Closes the old client, creates a new one, and spawns TDLib parameter initialization.
+    pub async fn recreate_client(&mut self, db_path: PathBuf) -> Result<(), String> {
+        // 1. Close old client
+        let _ = functions::close(self.client_id).await;
+
+        // 2. Create new client
+        let new_client = TdClient::new(TdClientConfig {
+            credentials: TdCredentials {
+                api_id: self.api_id,
+                api_hash: self.api_hash.clone(),
+            },
+            db_path,
+        });
+
+        // 3. Spawn set_tdlib_parameters for new client
+        let new_client_id = new_client.client_id;
+        let api_id = new_client.api_id;
+        let api_hash = new_client.api_hash.clone();
+        let db_path_str = new_client.db_path.to_string_lossy().to_string();
+
+        tokio::spawn(async move {
+            if let Err(e) = functions::set_tdlib_parameters(
+                false,
+                db_path_str,
+                "".to_string(),
+                "".to_string(),
+                true,
+                true,
+                true,
+                false,
+                api_id,
+                api_hash,
+                "en".to_string(),
+                "Desktop".to_string(),
+                "".to_string(),
+                env!("CARGO_PKG_VERSION").to_string(),
+                new_client_id,
+            )
+            .await
+            {
+                tracing::error!("set_tdlib_parameters failed on recreate: {:?}", e);
+            }
+        });
+
+        // 4. Replace self
+        *self = new_client;
+
+        Ok(())
+    }
+
+    pub fn extract_content_text(content: &tdlib_rs::enums::MessageContent) -> String {
+        use tdlib_rs::enums::MessageContent;
+        match content {
+            MessageContent::MessageText(text) => text.text.text.clone(),
+            _ => String::new(),
+        }
+    }
+}

crates/tele-core/src/tdlib/client_impl.rs

@@ -0,0 +1,332 @@
+//! Implementation of TdClientTrait for TdClient
+//!
+//! This file contains the trait implementation that delegates to existing TdClient methods.
+
+use super::client::TdClient;
+use super::r#trait::{
+    AccountClient, AuthClient, ChatActionClient, ChatClient, ClientState, FileClient,
+    MessageClient, ReactionClient, UpdateClient, UserClient,
+};
+use super::{
+    AuthState, ChatInfo, FolderInfo, MessageInfo, ProfileInfo, ReplyInfo, UserCache,
+    UserOnlineStatus,
+};
+use crate::types::{ChatId, MessageId, UserId};
+use async_trait::async_trait;
+use std::borrow::Cow;
+use std::path::PathBuf;
+use tdlib_rs::enums::{ChatAction, Update};
+
+#[async_trait]
+impl AuthClient for TdClient {
+    async fn send_phone_number(&self, phone: String) -> Result<(), String> {
+        self.send_phone_number(phone).await
+    }
+
+    async fn send_code(&self, code: String) -> Result<(), String> {
+        self.send_code(code).await
+    }
+
+    async fn send_password(&self, password: String) -> Result<(), String> {
+        self.send_password(password).await
+    }
+}
+
+#[async_trait]
+impl ChatClient for TdClient {
+    async fn load_chats(&mut self, limit: i32) -> Result<(), String> {
+        self.load_chats(limit).await
+    }
+
+    async fn load_folder_chats(&mut self, folder_id: i32, limit: i32) -> Result<(), String> {
+        self.load_folder_chats(folder_id, limit).await
+    }
+
+    async fn leave_chat(&self, chat_id: ChatId) -> Result<(), String> {
+        self.leave_chat(chat_id).await
+    }
+
+    async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String> {
+        self.get_profile_info(chat_id).await
+    }
+
+    fn chats(&self) -> &[ChatInfo] {
+        self.chats()
+    }
+
+    fn folders(&self) -> &[FolderInfo] {
+        self.folders()
+    }
+
+    fn main_chat_list_position(&self) -> i32 {
+        self.main_chat_list_position()
+    }
+
+    fn set_main_chat_list_position(&mut self, position: i32) {
+        self.set_main_chat_list_position(position)
+    }
+
+    fn update_chats<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<ChatInfo>),
+    {
+        TdClient::update_chats(self, updater);
+    }
+
+    fn update_folders<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<FolderInfo>),
+    {
+        TdClient::update_folders(self, updater);
+    }
+}
+
+#[async_trait]
+impl ChatActionClient for TdClient {
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        self.send_chat_action(chat_id, action).await
+    }
+
+    fn clear_stale_typing_status(&mut self) -> bool {
+        self.clear_stale_typing_status()
+    }
+
+    fn typing_status(&self) -> Option<&(UserId, String, std::time::Instant)> {
+        self.typing_status()
+    }
+
+    fn set_typing_status(&mut self, status: Option<(UserId, String, std::time::Instant)>) {
+        self.set_typing_status(status)
+    }
+}
+
+#[async_trait]
+impl MessageClient for TdClient {
+    async fn get_chat_history(
+        &mut self,
+        chat_id: ChatId,
+        limit: i32,
+    ) -> Result<Vec<MessageInfo>, String> {
+        self.get_chat_history(chat_id, limit).await
+    }
+
+    async fn load_older_messages(
+        &mut self,
+        chat_id: ChatId,
+        from_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        self.load_older_messages(chat_id, from_message_id).await
+    }
+
+    async fn get_pinned_messages(&mut self, chat_id: ChatId) -> Result<Vec<MessageInfo>, String> {
+        self.get_pinned_messages(chat_id).await
+    }
+
+    async fn load_current_pinned_message(&mut self, chat_id: ChatId) {
+        self.load_current_pinned_message(chat_id).await
+    }
+
+    async fn search_messages(
+        &self,
+        chat_id: ChatId,
+        query: &str,
+    ) -> Result<Vec<MessageInfo>, String> {
+        self.search_messages(chat_id, query).await
+    }
+
+    async fn send_message(
+        &mut self,
+        chat_id: ChatId,
+        text: String,
+        reply_to_message_id: Option<MessageId>,
+        reply_info: Option<ReplyInfo>,
+    ) -> Result<MessageInfo, String> {
+        TdClient::send_message(self, chat_id, text, reply_to_message_id, reply_info).await
+    }
+
+    async fn edit_message(
+        &mut self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        new_text: String,
+    ) -> Result<MessageInfo, String> {
+        TdClient::edit_message(self, chat_id, message_id, new_text).await
+    }
+
+    async fn delete_messages(
+        &mut self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String> {
+        self.message_manager
+            .delete_messages(chat_id, message_ids, revoke)
+            .await
+    }
+
+    async fn forward_messages(
+        &mut self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String> {
+        self.message_manager
+            .forward_messages(to_chat_id, from_chat_id, message_ids)
+            .await
+    }
+
+    async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String> {
+        self.set_draft_message(chat_id, text).await
+    }
+
+    fn current_chat_messages(&self) -> Cow<'_, [MessageInfo]> {
+        Cow::Borrowed(self.current_chat_messages())
+    }
+
+    fn current_chat_id(&self) -> Option<ChatId> {
+        self.current_chat_id()
+    }
+
+    fn current_pinned_message(&self) -> Option<MessageInfo> {
+        self.current_pinned_message().cloned()
+    }
+
+    fn push_message(&mut self, msg: MessageInfo) {
+        self.push_message(msg)
+    }
+
+    async fn fetch_missing_reply_info(&mut self) {
+        self.fetch_missing_reply_info().await
+    }
+
+    async fn process_pending_view_messages(&mut self) {
+        self.process_pending_view_messages().await
+    }
+
+    fn clear_current_chat_messages(&mut self) {
+        TdClient::clear_current_chat_messages(self)
+    }
+
+    fn set_current_chat_messages(&mut self, messages: Vec<MessageInfo>) {
+        TdClient::set_current_chat_messages(self, messages);
+    }
+
+    fn update_current_chat_messages<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<MessageInfo>),
+    {
+        TdClient::update_current_chat_messages(self, updater);
+    }
+
+    fn set_current_chat_id(&mut self, chat_id: Option<ChatId>) {
+        self.set_current_chat_id(chat_id)
+    }
+
+    fn set_current_pinned_message(&mut self, msg: Option<MessageInfo>) {
+        self.set_current_pinned_message(msg)
+    }
+
+    fn pending_view_messages(&self) -> &[(ChatId, Vec<MessageId>)] {
+        self.pending_view_messages()
+    }
+
+    fn enqueue_pending_view_messages(&mut self, chat_id: ChatId, message_ids: Vec<MessageId>) {
+        self.enqueue_pending_view_messages(chat_id, message_ids);
+    }
+}
+
+#[async_trait]
+impl UserClient for TdClient {
+    fn get_user_status_by_chat_id(&self, chat_id: ChatId) -> Option<&UserOnlineStatus> {
+        self.get_user_status_by_chat_id(chat_id)
+    }
+
+    fn pending_user_ids(&self) -> &[UserId] {
+        self.pending_user_ids()
+    }
+
+    fn user_cache(&self) -> &UserCache {
+        self.user_cache()
+    }
+
+    fn update_user_cache<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut UserCache),
+    {
+        TdClient::update_user_cache(self, updater);
+    }
+
+    async fn process_pending_user_ids(&mut self) {
+        self.process_pending_user_ids().await
+    }
+}
+
+#[async_trait]
+impl ReactionClient for TdClient {
+    async fn get_message_available_reactions(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+    ) -> Result<Vec<String>, String> {
+        self.get_message_available_reactions(chat_id, message_id)
+            .await
+    }
+
+    async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        reaction: String,
+    ) -> Result<(), String> {
+        self.toggle_reaction(chat_id, message_id, reaction).await
+    }
+}
+
+#[async_trait]
+impl FileClient for TdClient {
+    async fn download_file(&self, file_id: i32) -> Result<String, String> {
+        self.download_file(file_id).await
+    }
+
+    async fn download_voice_note(&self, file_id: i32) -> Result<String, String> {
+        // Voice notes use the same download mechanism as photos
+        self.download_file(file_id).await
+    }
+}
+
+#[async_trait]
+impl ClientState for TdClient {
+    fn client_id(&self) -> i32 {
+        self.client_id()
+    }
+
+    async fn get_me(&self) -> Result<i64, String> {
+        self.get_me().await
+    }
+
+    fn auth_state(&self) -> &AuthState {
+        self.auth_state()
+    }
+
+    fn network_state(&self) -> super::types::NetworkState {
+        self.network_state.clone()
+    }
+}
+
+#[async_trait]
+impl AccountClient for TdClient {
+    async fn recreate_client(&mut self, db_path: PathBuf) -> Result<(), String> {
+        TdClient::recreate_client(self, db_path).await
+    }
+}
+
+impl UpdateClient for TdClient {
+    fn handle_update(&mut self, update: Update) {
+        // Delegate to the real implementation
+        TdClient::handle_update(self, update)
+    }
+
+    fn drain_incoming_message_events(&mut self) -> Vec<super::IncomingMessageEvent> {
+        TdClient::drain_incoming_message_events(self)
+    }
+}

crates/tele-core/src/tdlib/message_conversion.rs

@@ -0,0 +1,213 @@
+//! Вспомогательные функции для конвертации TDLib сообщений в MessageInfo
+//!
+//! Этот модуль содержит функции для извлечения различных частей сообщения
+//! из TDLib Message и конвертации их в наш внутренний формат MessageInfo.
+
+use crate::types::MessageId;
+use tdlib_rs::enums::{MessageContent, MessageSender};
+use tdlib_rs::types::Message as TdMessage;
+
+use super::types::{
+    ForwardInfo, MediaInfo, PhotoDownloadState, PhotoInfo, ReactionInfo, ReplyInfo,
+    VoiceDownloadState, VoiceInfo,
+};
+
+/// Извлекает текст контента из TDLib Message
+///
+/// Обрабатывает различные типы сообщений (текст, фото, видео, стикеры, и т.д.)
+/// и возвращает текстовое представление.
+pub fn extract_content_text(msg: &TdMessage) -> String {
+    match &msg.content {
+        MessageContent::MessageText(t) => t.text.text.clone(),
+        MessageContent::MessagePhoto(p) => {
+            let caption_text = p.caption.text.clone();
+            if caption_text.is_empty() {
+                "📷 [Фото]".to_string()
+            } else {
+                format!("📷 {}", caption_text)
+            }
+        }
+        MessageContent::MessageVideo(v) => {
+            let caption_text = v.caption.text.clone();
+            if caption_text.is_empty() {
+                "[Видео]".to_string()
+            } else {
+                caption_text
+            }
+        }
+        MessageContent::MessageDocument(d) => {
+            let caption_text = d.caption.text.clone();
+            if caption_text.is_empty() {
+                format!("[Файл: {}]", d.document.file_name)
+            } else {
+                caption_text
+            }
+        }
+        MessageContent::MessageSticker(s) => {
+            format!("[Стикер: {}]", s.sticker.emoji)
+        }
+        MessageContent::MessageAnimation(a) => {
+            let caption_text = a.caption.text.clone();
+            if caption_text.is_empty() {
+                "[GIF]".to_string()
+            } else {
+                caption_text
+            }
+        }
+        MessageContent::MessageVoiceNote(v) => {
+            let duration = v.voice_note.duration;
+            let caption_text = v.caption.text.clone();
+            if caption_text.is_empty() {
+                format!("🎤 [Голосовое {:.0}s]", duration)
+            } else {
+                format!("🎤 {} ({:.0}s)", caption_text, duration)
+            }
+        }
+        MessageContent::MessageAudio(a) => {
+            let caption_text = a.caption.text.clone();
+            if caption_text.is_empty() {
+                let title = a.audio.title.clone();
+                let performer = a.audio.performer.clone();
+                if !title.is_empty() || !performer.is_empty() {
+                    format!("[Аудио: {} - {}]", performer, title)
+                } else {
+                    "[Аудио]".to_string()
+                }
+            } else {
+                caption_text
+            }
+        }
+        _ => "[Неподдерживаемый тип сообщения]".to_string(),
+    }
+}
+
+/// Извлекает entities (форматирование) из TDLib Message
+pub fn extract_entities(msg: &TdMessage) -> Vec<tdlib_rs::types::TextEntity> {
+    if let MessageContent::MessageText(t) = &msg.content {
+        t.text.entities.clone()
+    } else {
+        vec![]
+    }
+}
+
+/// Извлекает имя отправителя из TDLib Message
+///
+/// Для пользователей делает API вызов get_user для получения имени.
+/// Для чатов возвращает ID чата.
+pub async fn extract_sender_name(msg: &TdMessage, client_id: i32) -> String {
+    match &msg.sender_id {
+        MessageSender::User(user) => {
+            match tdlib_rs::functions::get_user(user.user_id, client_id).await {
+                Ok(tdlib_rs::enums::User::User(u)) => format!("{} {}", u.first_name, u.last_name)
+                    .trim()
+                    .to_string(),
+                _ => format!("User {}", user.user_id),
+            }
+        }
+        MessageSender::Chat(chat) => format!("Chat {}", chat.chat_id),
+    }
+}
+
+/// Извлекает информацию о пересылке из TDLib Message
+pub fn extract_forward_info(msg: &TdMessage) -> Option<ForwardInfo> {
+    msg.forward_info.as_ref().and_then(|fi| {
+        if let tdlib_rs::enums::MessageOrigin::User(origin_user) = &fi.origin {
+            Some(ForwardInfo {
+                sender_name: format!("User {}", origin_user.sender_user_id),
+            })
+        } else {
+            None
+        }
+    })
+}
+
+/// Извлекает информацию об ответе из TDLib Message
+pub fn extract_reply_info(msg: &TdMessage) -> Option<ReplyInfo> {
+    msg.reply_to.as_ref().and_then(|reply_to| {
+        if let tdlib_rs::enums::MessageReplyTo::Message(reply_msg) = reply_to {
+            Some(ReplyInfo {
+                message_id: MessageId::new(reply_msg.message_id),
+                sender_name: "Unknown".to_string(),
+                text: "...".to_string(),
+            })
+        } else {
+            None
+        }
+    })
+}
+
+/// Извлекает информацию о медиа-контенте из TDLib Message
+///
+/// Для MessagePhoto: получает лучший размер фото, извлекает file_id, width, height.
+/// Возвращает None для не-медийных типов сообщений.
+pub fn extract_media_info(msg: &TdMessage) -> Option<MediaInfo> {
+    match &msg.content {
+        MessageContent::MessagePhoto(p) => {
+            // Берём лучший (последний = самый большой) размер фото
+            let best_size = p.photo.sizes.last()?;
+            let file_id = best_size.photo.id;
+            let width = best_size.width;
+            let height = best_size.height;
+
+            // Проверяем, скачан ли файл
+            let download_state = if !best_size.photo.local.path.is_empty()
+                && best_size.photo.local.is_downloading_completed
+            {
+                PhotoDownloadState::Downloaded(best_size.photo.local.path.clone())
+            } else {
+                PhotoDownloadState::NotDownloaded
+            };
+
+            Some(MediaInfo::Photo(PhotoInfo { file_id, width, height, download_state }))
+        }
+        MessageContent::MessageVoiceNote(v) => {
+            let file_id = v.voice_note.voice.id;
+            let duration = v.voice_note.duration;
+            let mime_type = v.voice_note.mime_type.clone();
+            let waveform = v.voice_note.waveform.clone();
+
+            // Проверяем, скачан ли файл
+            let download_state = if !v.voice_note.voice.local.path.is_empty()
+                && v.voice_note.voice.local.is_downloading_completed
+            {
+                VoiceDownloadState::Downloaded(v.voice_note.voice.local.path.clone())
+            } else {
+                VoiceDownloadState::NotDownloaded
+            };
+
+            Some(MediaInfo::Voice(VoiceInfo {
+                file_id,
+                duration,
+                mime_type,
+                waveform,
+                download_state,
+            }))
+        }
+        _ => None,
+    }
+}
+
+/// Извлекает реакции из TDLib Message
+pub fn extract_reactions(msg: &TdMessage) -> Vec<ReactionInfo> {
+    msg.interaction_info
+        .as_ref()
+        .and_then(|ii| ii.reactions.as_ref())
+        .map(|reactions| {
+            reactions
+                .reactions
+                .iter()
+                .filter_map(|r| {
+                    if let tdlib_rs::enums::ReactionType::Emoji(emoji_type) = &r.r#type {
+                        Some(ReactionInfo {
+                            emoji: emoji_type.emoji.clone(),
+                            count: r.total_count,
+                            is_chosen: r.is_chosen,
+                        })
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}

crates/tele-core/src/tdlib/message_converter.rs

@@ -0,0 +1,234 @@
+//! Message conversion utilities for transforming TDLib messages.
+//!
+//! This module contains functions for converting TDLib message formats
+//! to the application's internal MessageInfo format, including extraction
+//! of replies, forwards, and reactions.
+
+use crate::types::{ChatId, MessageId, UserId};
+use tdlib_rs::types::Message as TdMessage;
+
+use super::client::TdClient;
+use super::types::{ForwardInfo, MessageInfo, ReactionInfo, ReplyInfo};
+
+/// Конвертирует TDLib сообщение в MessageInfo
+pub fn convert_message(client: &mut TdClient, message: &TdMessage, chat_id: ChatId) -> MessageInfo {
+    let sender_name = match &message.sender_id {
+        tdlib_rs::enums::MessageSender::User(user) => {
+            // Пробуем получить имя из кеша (get обновляет LRU порядок)
+            let user_id = UserId::new(user.user_id);
+            client
+                .user_cache
+                .user_names
+                .get(&user_id)
+                .cloned()
+                .unwrap_or_else(|| {
+                    // Добавляем в очередь для загрузки
+                    client.queue_pending_user_id(user_id);
+                    format!("User_{}", user_id.as_i64())
+                })
+        }
+        tdlib_rs::enums::MessageSender::Chat(chat) => {
+            // Для чатов используем название чата
+            let sender_chat_id = ChatId::new(chat.chat_id);
+            client
+                .chats()
+                .iter()
+                .find(|c| c.id == sender_chat_id)
+                .map(|c| c.title.clone())
+                .unwrap_or_else(|| format!("Chat_{}", sender_chat_id.as_i64()))
+        }
+    };
+
+    // Определяем, прочитано ли исходящее сообщение
+    let message_id = MessageId::new(message.id);
+    let is_read = if message.is_outgoing {
+        // Сообщение прочитано, если его ID <= last_read_outbox_message_id чата
+        client
+            .chats()
+            .iter()
+            .find(|c| c.id == chat_id)
+            .map(|c| message_id <= c.last_read_outbox_message_id)
+            .unwrap_or(false)
+    } else {
+        true // Входящие сообщения не показывают галочки
+    };
+
+    let (content, entities) = TdClient::extract_message_text_static(message);
+
+    // Извлекаем информацию о reply
+    let reply_to = extract_reply_info(client, message);
+
+    // Извлекаем информацию о forward
+    let forward_from = extract_forward_info(client, message);
+
+    // Извлекаем реакции
+    let reactions = extract_reactions(client, message);
+
+    // Используем MessageBuilder для более читабельного создания
+    let mut builder = crate::tdlib::MessageBuilder::new(message_id)
+        .sender_name(sender_name)
+        .text(content)
+        .entities(entities)
+        .date(message.date)
+        .edit_date(message.edit_date)
+        .media_album_id(message.media_album_id);
+
+    // Применяем флаги
+    if message.is_outgoing {
+        builder = builder.outgoing();
+    }
+    if is_read {
+        builder = builder.read();
+    }
+    if message.can_be_edited {
+        builder = builder.editable();
+    }
+    if message.can_be_deleted_only_for_self {
+        builder = builder.deletable_for_self();
+    }
+    if message.can_be_deleted_for_all_users {
+        builder = builder.deletable_for_all();
+    }
+
+    // Добавляем опциональные данные
+    if let Some(reply) = reply_to {
+        builder = builder.reply_to(reply);
+    }
+    if let Some(forward) = forward_from {
+        builder = builder.forward_from(forward);
+    }
+    if !reactions.is_empty() {
+        builder = builder.reactions(reactions);
+    }
+
+    builder.build()
+}
+
+/// Извлекает информацию о reply из сообщения
+pub fn extract_reply_info(client: &TdClient, message: &TdMessage) -> Option<ReplyInfo> {
+    use tdlib_rs::enums::MessageReplyTo;
+
+    match &message.reply_to {
+        Some(MessageReplyTo::Message(reply)) => {
+            // Получаем имя отправителя из origin или ищем сообщение в текущем списке
+            let sender_name = reply
+                .origin
+                .as_ref()
+                .map(get_origin_sender_name)
+                .unwrap_or_else(|| {
+                    // Пробуем найти оригинальное сообщение в текущем списке
+                    let reply_msg_id = MessageId::new(reply.message_id);
+                    client
+                        .current_chat_messages()
+                        .iter()
+                        .find(|m| m.id() == reply_msg_id)
+                        .map(|m| m.sender_name().to_string())
+                        .unwrap_or_else(|| "...".to_string())
+                });
+
+            // Получаем текст из content или quote
+            let reply_msg_id = MessageId::new(reply.message_id);
+            let text = reply
+                .quote
+                .as_ref()
+                .map(|q| q.text.text.clone())
+                .or_else(|| reply.content.as_ref().map(TdClient::extract_content_text))
+                .unwrap_or_else(|| {
+                    // Пробуем найти в текущих сообщениях
+                    client
+                        .current_chat_messages()
+                        .iter()
+                        .find(|m| m.id() == reply_msg_id)
+                        .map(|m| m.text().to_string())
+                        .unwrap_or_default()
+                });
+
+            Some(ReplyInfo { message_id: reply_msg_id, sender_name, text })
+        }
+        _ => None,
+    }
+}
+
+/// Извлекает информацию о forward из сообщения
+pub fn extract_forward_info(_client: &TdClient, message: &TdMessage) -> Option<ForwardInfo> {
+    message.forward_info.as_ref().map(|info| {
+        let sender_name = get_origin_sender_name(&info.origin);
+        ForwardInfo { sender_name }
+    })
+}
+
+/// Извлекает реакции из сообщения
+pub fn extract_reactions(_client: &TdClient, message: &TdMessage) -> Vec<ReactionInfo> {
+    message
+        .interaction_info
+        .as_ref()
+        .and_then(|info| info.reactions.as_ref())
+        .map(|reactions| {
+            reactions
+                .reactions
+                .iter()
+                .filter_map(|reaction| {
+                    let emoji = match &reaction.r#type {
+                        tdlib_rs::enums::ReactionType::Emoji(e) => e.emoji.clone(),
+                        tdlib_rs::enums::ReactionType::CustomEmoji(_) => return None,
+                    };
+
+                    Some(ReactionInfo {
+                        emoji,
+                        count: reaction.total_count,
+                        is_chosen: reaction.is_chosen,
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Получает имя отправителя из MessageOrigin
+fn get_origin_sender_name(origin: &tdlib_rs::enums::MessageOrigin) -> String {
+    use tdlib_rs::enums::MessageOrigin;
+
+    match origin {
+        MessageOrigin::User(u) => format!("User_{}", u.sender_user_id),
+        MessageOrigin::Chat(c) => format!("Chat_{}", c.sender_chat_id),
+        MessageOrigin::Channel(c) => c.author_signature.clone(),
+        MessageOrigin::HiddenUser(h) => h.sender_name.clone(),
+    }
+}
+
+/// Обновляет reply info для сообщений, где данные не были загружены
+/// Вызывается после загрузки истории, когда все сообщения уже в списке
+#[allow(dead_code)]
+pub fn update_reply_info_from_loaded_messages(client: &mut TdClient) {
+    // Собираем данные для обновления (id -> (sender_name, content))
+    let msg_data: std::collections::HashMap<i64, (String, String)> = client
+        .current_chat_messages()
+        .iter()
+        .map(|m| (m.id().as_i64(), (m.sender_name().to_string(), m.text().to_string())))
+        .collect();
+
+    // Обновляем reply_to для сообщений с неполными данными
+    client.update_current_chat_messages(|messages| {
+        for msg in messages {
+            let Some(ref mut reply) = msg.interactions.reply_to else {
+                continue;
+            };
+
+            // Если sender_name = "..." или text пустой — пробуем заполнить
+            if reply.sender_name != "..." && !reply.text.is_empty() {
+                continue;
+            }
+
+            let Some((sender, content)) = msg_data.get(&reply.message_id.as_i64()) else {
+                continue;
+            };
+
+            if reply.sender_name == "..." {
+                reply.sender_name = sender.clone();
+            }
+            if reply.text.is_empty() {
+                reply.text = content.clone();
+            }
+        }
+    });
+}

crates/tele-core/src/tdlib/messages/convert.rs

@@ -0,0 +1,142 @@
+//! TDLib message conversion: JSON → MessageInfo, reply info fetching.
+
+use crate::types::{ChatId, MessageId};
+use tdlib_rs::functions;
+use tdlib_rs::types::Message as TdMessage;
+
+use crate::tdlib::types::{MessageBuilder, MessageInfo};
+
+use super::MessageManager;
+
+impl MessageManager {
+    /// Конвертировать TdMessage в MessageInfo
+    pub(crate) async fn convert_message(
+        &self,
+        msg: &TdMessage,
+        last_read_outbox_message_id: MessageId,
+    ) -> Option<MessageInfo> {
+        use crate::tdlib::message_conversion::{
+            extract_content_text, extract_entities, extract_forward_info, extract_media_info,
+            extract_reactions, extract_reply_info, extract_sender_name,
+        };
+
+        // Извлекаем все части сообщения используя вспомогательные функции
+        let content_text = extract_content_text(msg);
+        let entities = extract_entities(msg);
+        let sender_name = extract_sender_name(msg, self.client_id).await;
+        let forward_from = extract_forward_info(msg);
+        let reply_to = extract_reply_info(msg);
+        let reactions = extract_reactions(msg);
+        let media = extract_media_info(msg);
+
+        let mut builder = MessageBuilder::new(MessageId::new(msg.id))
+            .sender_name(sender_name)
+            .text(content_text)
+            .entities(entities)
+            .date(msg.date)
+            .edit_date(msg.edit_date)
+            .media_album_id(msg.media_album_id);
+
+        if msg.is_outgoing {
+            builder = builder.outgoing();
+        } else {
+            builder = builder.incoming();
+        }
+
+        let is_read = !msg.is_outgoing || msg.id <= last_read_outbox_message_id.as_i64();
+        if is_read {
+            builder = builder.read();
+        } else {
+            builder = builder.unread();
+        }
+
+        if msg.can_be_edited {
+            builder = builder.editable();
+        }
+
+        if msg.can_be_deleted_only_for_self {
+            builder = builder.deletable_for_self();
+        }
+
+        if msg.can_be_deleted_for_all_users {
+            builder = builder.deletable_for_all();
+        }
+
+        if let Some(reply) = reply_to {
+            builder = builder.reply_to(reply);
+        }
+
+        if let Some(forward) = forward_from {
+            builder = builder.forward_from(forward);
+        }
+
+        builder = builder.reactions(reactions);
+
+        if let Some(media) = media {
+            builder = builder.media(media);
+        }
+
+        Some(builder.build())
+    }
+
+    /// Загружает недостающую информацию об исходных сообщениях для ответов.
+    ///
+    /// Ищет все reply-сообщения с `sender_name == "Unknown"` и загружает
+    /// полную информацию (имя отправителя, текст) из TDLib.
+    ///
+    /// # Note
+    ///
+    /// Вызывайте после загрузки истории чата для заполнения информации о цитируемых сообщениях.
+    pub async fn fetch_missing_reply_info(&mut self) {
+        // Early return if no chat selected
+        let Some(chat_id) = self.current_chat_id else {
+            return;
+        };
+
+        // Collect message IDs with missing reply info using filter_map
+        let to_fetch: Vec<MessageId> = self
+            .current_chat_messages
+            .iter()
+            .filter_map(|msg| {
+                msg.interactions
+                    .reply_to
+                    .as_ref()
+                    .filter(|reply| reply.sender_name == "Unknown")
+                    .map(|reply| reply.message_id)
+            })
+            .collect();
+
+        // Fetch and update each missing message
+        for message_id in to_fetch {
+            self.fetch_and_update_reply(chat_id, message_id).await;
+        }
+    }
+
+    /// Загружает одно сообщение и обновляет reply информацию.
+    async fn fetch_and_update_reply(&mut self, chat_id: ChatId, message_id: MessageId) {
+        // Try to fetch the original message
+        let Ok(original_msg_enum) =
+            functions::get_message(chat_id.as_i64(), message_id.as_i64(), self.client_id).await
+        else {
+            return;
+        };
+
+        let tdlib_rs::enums::Message::Message(original_msg) = original_msg_enum;
+        let Some(orig_info) = self.convert_message(&original_msg, MessageId::new(0)).await else {
+            return;
+        };
+
+        // Extract text preview (first 50 chars)
+        let text_preview: String = orig_info.content.text.chars().take(50).collect();
+
+        // Update reply info in all messages that reference this message
+        self.current_chat_messages
+            .iter_mut()
+            .filter_map(|msg| msg.interactions.reply_to.as_mut())
+            .filter(|reply| reply.message_id == message_id)
+            .for_each(|reply| {
+                reply.sender_name = orig_info.metadata.sender_name.clone();
+                reply.text = text_preview.clone();
+            });
+    }
+}

crates/tele-core/src/tdlib/messages/mod.rs

@@ -0,0 +1,102 @@
+//! Message management: storage, conversion, and TDLib API operations.
+
+mod convert;
+mod operations;
+
+use crate::constants::MAX_MESSAGES_IN_CHAT;
+use crate::types::{ChatId, MessageId};
+
+use super::types::MessageInfo;
+
+/// Менеджер сообщений TDLib.
+///
+/// Управляет загрузкой, отправкой, редактированием и удалением сообщений.
+/// Кеширует сообщения текущего открытого чата и закрепленные сообщения.
+///
+/// # Основные возможности
+///
+/// - Загрузка истории сообщений чата
+/// - Отправка текстовых сообщений с поддержкой Markdown
+/// - Редактирование и удаление сообщений
+/// - Пересылка сообщений между чатами
+/// - Поиск сообщений по тексту
+/// - Управление закрепленными сообщениями
+/// - Управление черновиками
+/// - Автоматическая отметка сообщений как прочитанных
+///
+/// # Examples
+///
+/// ```ignore
+/// let mut msg_manager = MessageManager::new(client_id);
+///
+/// // Загрузить историю чата
+/// let messages = msg_manager.get_chat_history(chat_id, 50).await?;
+///
+/// // Отправить сообщение
+/// let msg = msg_manager.send_message(
+///     chat_id,
+///     "Hello, **world**!".to_string(),
+///     None,
+///     None
+/// ).await?;
+/// ```
+pub struct MessageManager {
+    /// Список сообщений текущего открытого чата (до MAX_MESSAGES_IN_CHAT).
+    pub current_chat_messages: Vec<MessageInfo>,
+
+    /// ID текущего открытого чата.
+    pub current_chat_id: Option<ChatId>,
+
+    /// Текущее закрепленное сообщение открытого чата.
+    pub current_pinned_message: Option<MessageInfo>,
+
+    /// Очередь сообщений для отметки как прочитанных: (chat_id, message_ids).
+    pub pending_view_messages: Vec<(ChatId, Vec<MessageId>)>,
+
+    /// ID клиента TDLib для API вызовов.
+    pub(crate) client_id: i32,
+}
+
+impl MessageManager {
+    /// Создает новый менеджер сообщений.
+    ///
+    /// # Arguments
+    ///
+    /// * `client_id` - ID клиента TDLib для API вызовов
+    ///
+    /// # Returns
+    ///
+    /// Новый экземпляр `MessageManager` с пустым списком сообщений.
+    pub fn new(client_id: i32) -> Self {
+        Self {
+            current_chat_messages: Vec::new(),
+            current_chat_id: None,
+            current_pinned_message: None,
+            pending_view_messages: Vec::new(),
+            client_id,
+        }
+    }
+
+    /// Добавляет сообщение в список текущего чата.
+    ///
+    /// Автоматически ограничивает размер списка до [`MAX_MESSAGES_IN_CHAT`],
+    /// удаляя старые сообщения при превышении лимита.
+    ///
+    /// # Arguments
+    ///
+    /// * `msg` - Сообщение для добавления
+    ///
+    /// # Note
+    ///
+    /// Сообщение добавляется в конец списка. При превышении лимита
+    /// удаляются самые старые сообщения из начала списка.
+    pub fn push_message(&mut self, msg: MessageInfo) {
+        self.current_chat_messages.push(msg); // Добавляем в конец
+
+        // Ограничиваем размер списка (удаляем старые с начала)
+        if self.current_chat_messages.len() > MAX_MESSAGES_IN_CHAT {
+            self.current_chat_messages
+                .drain(0..(self.current_chat_messages.len() - MAX_MESSAGES_IN_CHAT));
+        }
+    }
+}

crates/tele-core/src/tdlib/messages/operations.rs

@@ -0,0 +1,625 @@
+//! TDLib message API operations: history, send, edit, delete, forward, search.
+
+use crate::constants::TDLIB_MESSAGE_LIMIT;
+use crate::types::{ChatId, MessageId};
+use tdlib_rs::enums::{
+    InputMessageContent, InputMessageReplyTo, SearchMessagesFilter, TextParseMode,
+};
+use tdlib_rs::functions;
+use tdlib_rs::types::{
+    FormattedText, InputMessageReplyToMessage, InputMessageText, TextParseModeMarkdown,
+};
+use tokio::time::{sleep, Duration};
+
+use crate::tdlib::types::{MessageInfo, ReplyInfo};
+
+use super::MessageManager;
+
+impl MessageManager {
+    /// Загружает историю сообщений чата с динамической подгрузкой.
+    ///
+    /// Загружает сообщения чанками, ожидая пока TDLib синхронизирует их с сервера.
+    /// Продолжает загрузку пока не будет достигнут `limit` или пока TDLib отдает сообщения.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `limit` - Желаемое минимальное количество сообщений (для заполнения экрана)
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Vec<MessageInfo>)` - Список сообщений (от старых к новым)
+    /// * `Err(String)` - Ошибка загрузки
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // Загрузить достаточно сообщений для экрана высотой 30 строк
+    /// let messages = msg_manager.get_chat_history(chat_id, 30).await?;
+    /// ```
+    pub async fn get_chat_history(
+        &mut self,
+        chat_id: ChatId,
+        limit: i32,
+        last_read_outbox_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        // ВАЖНО: Сначала открываем чат в TDLib
+        // Это сообщает TDLib что пользователь открыл чат и нужно загрузить историю
+        let _ = functions::open_chat(chat_id.as_i64(), self.client_id).await;
+
+        // Открываем чат - TDLib начнет синхронизацию автоматически
+
+        // НЕ устанавливаем current_chat_id здесь!
+        // Он будет установлен снаружи ПОСЛЕ сохранения истории
+        // Это предотвращает race condition с Update::NewMessage
+
+        let mut all_messages = Vec::new();
+        let mut from_message_id = 0i64; // 0 = начинаем с последних сообщений
+        let max_attempts_per_chunk = 20; // Максимум попыток на чанк
+        let mut consecutive_empty_results = 0; // Счетчик пустых результатов подряд
+
+        // Загружаем чанками по TDLIB_MESSAGE_LIMIT пока не достигнем limit
+        while (all_messages.len() as i32) < limit {
+            let remaining = limit - (all_messages.len() as i32);
+            let chunk_size = std::cmp::min(TDLIB_MESSAGE_LIMIT, remaining);
+
+            let mut chunk_loaded = false;
+
+            // Пробуем загрузить чанк (TDLib подгружает с сервера по мере готовности)
+            for attempt in 1..=max_attempts_per_chunk {
+                let result = functions::get_chat_history(
+                    chat_id.as_i64(),
+                    from_message_id,
+                    0, // offset
+                    chunk_size,
+                    false, // only_local - false means can fetch from server
+                    self.client_id,
+                )
+                .await;
+
+                let messages_obj = match result {
+                    Ok(tdlib_rs::enums::Messages::Messages(obj)) => obj,
+                    Err(e) => {
+                        // При первой загрузке (from_message_id == 0) возвращаем ошибку
+                        // При последующих чанках - прерываем цикл (возможно кончились сообщения)
+                        if all_messages.is_empty() {
+                            return Err(format!("Ошибка загрузки истории: {:?}", e));
+                        } else {
+                            break;
+                        }
+                    }
+                };
+
+                let received_count = messages_obj.messages.len();
+
+                // Если получили пустой результат
+                if messages_obj.messages.is_empty() {
+                    consecutive_empty_results += 1;
+                    // Если несколько раз подряд пусто - прерываем
+                    if consecutive_empty_results >= 3 {
+                        break;
+                    }
+                    // Пробуем еще раз
+                    continue;
+                }
+
+                // Получили сообщения - сбрасываем счетчик
+                consecutive_empty_results = 0;
+
+                // Если это первая загрузка и получили мало сообщений - продолжаем попытки
+                // TDLib может подгружать данные с сервера постепенно
+                if all_messages.is_empty()
+                    && received_count < (chunk_size as usize)
+                    && attempt < max_attempts_per_chunk
+                {
+                    // Даём TDLib время на синхронизацию с сервером
+                    sleep(Duration::from_millis(100)).await;
+                    continue;
+                }
+
+                // Конвертируем сообщения (от новых к старым, потом реверсим)
+                let mut chunk_messages = Vec::new();
+                for msg in messages_obj.messages.iter().flatten() {
+                    if let Some(info) = self.convert_message(msg, last_read_outbox_message_id).await
+                    {
+                        chunk_messages.push(info);
+                    }
+                }
+
+                // Реверсим чтобы получить порядок от старых к новым
+                chunk_messages.reverse();
+
+                // Добавляем загруженные сообщения
+                if !chunk_messages.is_empty() {
+                    // Для следующей итерации: ID самого старого сообщения из текущего чанка
+                    from_message_id = chunk_messages[0].id().as_i64();
+
+                    // ВАЖНО: Вставляем чанк В НАЧАЛО списка!
+                    // Первый чанк содержит НОВЫЕ сообщения (например 51-100)
+                    // Второй чанк содержит СТАРЫЕ сообщения (например 1-50)
+                    // Поэтому более старые чанки должны быть в начале списка
+                    if all_messages.is_empty() {
+                        // Первый чанк - просто добавляем
+                        all_messages = chunk_messages;
+                    } else {
+                        // Последующие чанки - вставляем в начало
+                        all_messages.splice(0..0, chunk_messages);
+                    }
+
+                    chunk_loaded = true;
+                }
+
+                // Если получили меньше чем chunk_size, значит это последний доступный чанк
+                if (messages_obj.messages.len() as i32) < chunk_size {
+                    return Ok(all_messages);
+                }
+
+                break; // Чанк успешно загружен
+            }
+
+            // Если чанк не загрузился после всех попыток - прерываем
+            if !chunk_loaded {
+                break;
+            }
+        }
+
+        Ok(all_messages)
+    }
+
+    /// Загружает более старые сообщения для пагинации.
+    ///
+    /// Используется для подгрузки предыдущих сообщений при прокрутке
+    /// истории чата вверх.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `from_message_id` - ID сообщения, от которого загружать историю
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Vec<MessageInfo>)` - Список старых сообщений (от старых к новым)
+    /// * `Err(String)` - Ошибка загрузки
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // Загрузить сообщения старше указанного
+    /// let older = msg_manager.load_older_messages(
+    ///     chat_id,
+    ///     MessageId::new(12345)
+    /// ).await?;
+    /// ```
+    pub async fn load_older_messages(
+        &mut self,
+        chat_id: ChatId,
+        from_message_id: MessageId,
+        last_read_outbox_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let result = functions::get_chat_history(
+            chat_id.as_i64(),
+            from_message_id.as_i64(),
+            0, // offset
+            TDLIB_MESSAGE_LIMIT,
+            false,
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(tdlib_rs::enums::Messages::Messages(messages_obj)) => {
+                let mut messages = Vec::new();
+                for msg in messages_obj.messages.iter().rev().flatten() {
+                    if let Some(info) = self.convert_message(msg, last_read_outbox_message_id).await
+                    {
+                        messages.push(info);
+                    }
+                }
+                Ok(messages)
+            }
+            Err(e) => Err(format!("Ошибка загрузки старых сообщений: {:?}", e)),
+        }
+    }
+
+    /// Получает все закрепленные сообщения чата.
+    ///
+    /// Выполняет поиск всех сообщений с фильтром "pinned" и возвращает их список.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Vec<MessageInfo>)` - Список закрепленных сообщений (до 100)
+    /// * `Err(String)` - Ошибка загрузки
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// let pinned = msg_manager.get_pinned_messages(chat_id).await?;
+    /// println!("Found {} pinned messages", pinned.len());
+    /// ```
+    pub async fn get_pinned_messages(
+        &mut self,
+        chat_id: ChatId,
+        last_read_outbox_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let result = functions::search_chat_messages(
+            chat_id.as_i64(),
+            String::new(),
+            None,
+            0,   // from_message_id
+            0,   // offset
+            100, // limit
+            Some(SearchMessagesFilter::Pinned),
+            0, // message_thread_id
+            0, // saved_messages_topic_id
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(tdlib_rs::enums::FoundChatMessages::FoundChatMessages(messages_obj)) => {
+                let mut pinned_messages = Vec::new();
+                for msg in messages_obj.messages.iter().rev() {
+                    if let Some(info) = self.convert_message(msg, last_read_outbox_message_id).await
+                    {
+                        pinned_messages.push(info);
+                    }
+                }
+                Ok(pinned_messages)
+            }
+            Err(e) => Err(format!("Ошибка загрузки закреплённых: {:?}", e)),
+        }
+    }
+
+    /// Загружает текущее верхнее закрепленное сообщение.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    ///
+    /// # Compatibility
+    ///
+    /// The current `tdlib-rs` schema no longer exposes `Chat.pinned_message_id`, and the
+    /// generated wrapper does not provide `getChatPinnedMessage`. The pinned-message modal
+    /// uses `get_pinned_messages` with `SearchMessagesFilter::Pinned`; this method keeps the
+    /// legacy single-header state empty until TDLib exposes a direct top-pinned-message API.
+    pub async fn load_current_pinned_message(&mut self, _chat_id: ChatId) {
+        self.current_pinned_message = None;
+    }
+
+    /// Выполняет поиск сообщений по тексту в указанном чате.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата для поиска
+    /// * `query` - Текстовый запрос для поиска
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Vec<MessageInfo>)` - Найденные сообщения (до 100)
+    /// * `Err(String)` - Ошибка поиска
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// let results = msg_manager.search_messages(chat_id, "hello").await?;
+    /// ```
+    pub async fn search_messages(
+        &self,
+        chat_id: ChatId,
+        query: &str,
+        last_read_outbox_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        let result = functions::search_chat_messages(
+            chat_id.as_i64(),
+            query.to_string(),
+            None,
+            0,   // from_message_id
+            0,   // offset
+            100, // limit
+            None,
+            0, // message_thread_id
+            0, // saved_messages_topic_id
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(tdlib_rs::enums::FoundChatMessages::FoundChatMessages(messages_obj)) => {
+                let mut search_results = Vec::new();
+                for msg in messages_obj.messages.iter().rev() {
+                    if let Some(info) = self.convert_message(msg, last_read_outbox_message_id).await
+                    {
+                        search_results.push(info);
+                    }
+                }
+                Ok(search_results)
+            }
+            Err(e) => Err(format!("Ошибка поиска: {:?}", e)),
+        }
+    }
+
+    /// Отправляет текстовое сообщение в чат с поддержкой Markdown.
+    ///
+    /// Автоматически парсит Markdown v2 форматирование (**bold**, *italic*, `code` и т.д.).
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата-получателя
+    /// * `text` - Текст сообщения (поддерживает Markdown v2)
+    /// * `reply_to_message_id` - Опциональный ID сообщения для ответа
+    /// * `reply_info` - Опциональная информация об исходном сообщении
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(MessageInfo)` - Отправленное сообщение
+    /// * `Err(String)` - Ошибка отправки
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // Простое сообщение
+    /// let msg = msg_manager.send_message(
+    ///     chat_id,
+    ///     "Hello, **world**!".to_string(),
+    ///     None,
+    ///     None
+    /// ).await?;
+    ///
+    /// // Ответ на сообщение
+    /// let reply = msg_manager.send_message(
+    ///     chat_id,
+    ///     "Got it!".to_string(),
+    ///     Some(MessageId::new(123)),
+    ///     Some(reply_info)
+    /// ).await?;
+    /// ```
+    pub async fn send_message(
+        &self,
+        chat_id: ChatId,
+        text: String,
+        reply_to_message_id: Option<MessageId>,
+        reply_info: Option<ReplyInfo>,
+        last_read_outbox_message_id: MessageId,
+    ) -> Result<MessageInfo, String> {
+        // Парсим markdown в тексте
+        let formatted_text = match functions::parse_text_entities(
+            text.clone(),
+            TextParseMode::Markdown(TextParseModeMarkdown { version: 2 }),
+            self.client_id,
+        )
+        .await
+        {
+            Ok(tdlib_rs::enums::FormattedText::FormattedText(ft)) => {
+                FormattedText { text: ft.text, entities: ft.entities }
+            }
+            Err(_) => FormattedText { text: text.clone(), entities: vec![] },
+        };
+
+        let content = InputMessageContent::InputMessageText(InputMessageText {
+            text: formatted_text,
+            link_preview_options: None,
+            clear_draft: true,
+        });
+
+        let reply_to = reply_to_message_id.map(|msg_id| {
+            InputMessageReplyTo::Message(InputMessageReplyToMessage {
+                chat_id: 0,
+                message_id: msg_id.as_i64(),
+                quote: None,
+            })
+        });
+
+        let result = functions::send_message(
+            chat_id.as_i64(),
+            0, // message_thread_id
+            reply_to,
+            None, // options
+            content,
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(tdlib_rs::enums::Message::Message(msg)) => {
+                let mut msg_info = self
+                    .convert_message(&msg, last_read_outbox_message_id)
+                    .await
+                    .ok_or_else(|| "Не удалось конвертировать сообщение".to_string())?;
+
+                // Добавляем reply_info если был передан
+                if let Some(reply) = reply_info {
+                    msg_info.interactions.reply_to = Some(reply);
+                }
+
+                Ok(msg_info)
+            }
+            Err(e) => Err(format!("Ошибка отправки сообщения: {:?}", e)),
+        }
+    }
+
+    /// Редактирует существующее сообщение.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `message_id` - ID сообщения для редактирования
+    /// * `text` - Новый текст (поддерживает Markdown v2)
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(MessageInfo)` - Отредактированное сообщение
+    /// * `Err(String)` - Ошибка (нет прав, сообщение слишком старое и т.д.)
+    pub async fn edit_message(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        text: String,
+        last_read_outbox_message_id: MessageId,
+    ) -> Result<MessageInfo, String> {
+        let formatted_text = match functions::parse_text_entities(
+            text.clone(),
+            TextParseMode::Markdown(TextParseModeMarkdown { version: 2 }),
+            self.client_id,
+        )
+        .await
+        {
+            Ok(tdlib_rs::enums::FormattedText::FormattedText(ft)) => {
+                FormattedText { text: ft.text, entities: ft.entities }
+            }
+            Err(_) => FormattedText { text: text.clone(), entities: vec![] },
+        };
+
+        let content = InputMessageContent::InputMessageText(InputMessageText {
+            text: formatted_text,
+            link_preview_options: None,
+            clear_draft: true,
+        });
+
+        let result = functions::edit_message_text(
+            chat_id.as_i64(),
+            message_id.as_i64(),
+            content,
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(tdlib_rs::enums::Message::Message(msg)) => self
+                .convert_message(&msg, last_read_outbox_message_id)
+                .await
+                .ok_or_else(|| "Не удалось конвертировать отредактированное сообщение".to_string()),
+            Err(e) => Err(format!("Ошибка редактирования: {:?}", e)),
+        }
+    }
+
+    /// Удаляет одно или несколько сообщений.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `message_ids` - Список ID сообщений для удаления
+    /// * `revoke` - `true` - удалить для всех, `false` - только для себя
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Сообщения удалены
+    /// * `Err(String)` - Ошибка удаления
+    pub async fn delete_messages(
+        &self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String> {
+        let message_ids_i64: Vec<i64> = message_ids.into_iter().map(|id| id.as_i64()).collect();
+        let result =
+            functions::delete_messages(chat_id.as_i64(), message_ids_i64, revoke, self.client_id)
+                .await;
+        match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(format!("Ошибка удаления: {:?}", e)),
+        }
+    }
+
+    /// Пересылает сообщения из одного чата в другой.
+    ///
+    /// # Arguments
+    ///
+    /// * `to_chat_id` - ID чата-получателя
+    /// * `from_chat_id` - ID чата-источника
+    /// * `message_ids` - Список ID сообщений для пересылки
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Сообщения переслань
+    /// * `Err(String)` - Ошибка пересылки
+    pub async fn forward_messages(
+        &self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String> {
+        let message_ids_i64: Vec<i64> = message_ids.into_iter().map(|id| id.as_i64()).collect();
+        let result = functions::forward_messages(
+            to_chat_id.as_i64(),
+            0, // message_thread_id
+            from_chat_id.as_i64(),
+            message_ids_i64,
+            None,  // options
+            false, // send_copy
+            false, // remove_caption
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(format!("Ошибка пересылки: {:?}", e)),
+        }
+    }
+
+    /// Сохраняет черновик сообщения для чата.
+    ///
+    /// Черновик отображается в списке чатов и восстанавливается
+    /// при следующем открытии чата.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `text` - Текст черновика (пустая строка удаляет черновик)
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Черновик сохранен
+    /// * `Err(String)` - Ошибка сохранения
+    pub async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String> {
+        use tdlib_rs::types::DraftMessage;
+
+        let draft = if text.is_empty() {
+            None
+        } else {
+            Some(DraftMessage {
+                reply_to: None,
+                date: 0,
+                input_message_text: InputMessageContent::InputMessageText(InputMessageText {
+                    text: FormattedText { text: text.clone(), entities: vec![] },
+                    link_preview_options: None,
+                    clear_draft: false,
+                }),
+            })
+        };
+
+        let result =
+            functions::set_chat_draft_message(chat_id.as_i64(), 0, draft, self.client_id).await;
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(format!("Ошибка сохранения черновика: {:?}", e)),
+        }
+    }
+
+    /// Обрабатывает очередь сообщений для отметки как прочитанных.
+    ///
+    /// Автоматически отмечает просмотренные сообщения как прочитанные,
+    /// что сбрасывает счетчик непрочитанных сообщений в чате.
+    ///
+    /// # Note
+    ///
+    /// Вызывайте периодически (например, в основном цикле) для обработки накопленной очереди.
+    pub async fn process_pending_view_messages(&mut self) {
+        if self.pending_view_messages.is_empty() {
+            return;
+        }
+
+        let batch = std::mem::take(&mut self.pending_view_messages);
+
+        for (chat_id, message_ids) in batch {
+            let ids: Vec<i64> = message_ids.iter().map(|id| id.as_i64()).collect();
+            let _ =
+                functions::view_messages(chat_id.as_i64(), ids, None, true, self.client_id).await;
+        }
+    }
+}

crates/tele-core/src/tdlib/mod.rs

@@ -0,0 +1,37 @@
+// Модули
+pub mod auth;
+mod chat_helpers; // Chat management helpers
+pub mod chats;
+pub mod client;
+mod client_impl; // Private module for trait implementation
+pub mod message_conversion; // Message conversion utilities (for messages.rs)
+mod message_converter; // Message conversion utilities (for client.rs)
+pub mod messages;
+pub mod reactions;
+pub mod r#trait;
+pub mod types;
+mod update_handlers; // Update handlers extracted from client
+pub mod users;
+
+// Экспорт основных типов
+pub use auth::AuthState;
+pub use client::TdClient;
+#[allow(unused_imports)]
+pub use r#trait::{
+    AccountClient, AuthClient, ChatActionClient, ChatClient, ClientState, FileClient,
+    MessageClient, ReactionClient, TdClientTrait, UpdateClient, UserClient,
+};
+#[allow(unused_imports)]
+pub use types::{
+    ChatInfo, FolderInfo, MediaInfo, MessageBuilder, MessageInfo, NetworkState, PhotoDownloadState,
+    PhotoInfo, PlaybackState, PlaybackStatus, ProfileInfo, ReplyInfo, UserOnlineStatus,
+    VoiceDownloadState, VoiceInfo,
+};
+
+pub use client::{IncomingMessageEvent, TdClientConfig, TdCredentials};
+#[cfg(feature = "images")]
+pub use types::ImageModalState;
+pub use users::UserCache;
+
+// Re-export ChatAction для удобства
+pub use tdlib_rs::enums::ChatAction;

crates/tele-core/src/tdlib/reactions.rs

@@ -0,0 +1,230 @@
+use crate::types::{ChatId, MessageId};
+use tdlib_rs::enums::{AvailableReactions, ReactionType};
+use tdlib_rs::functions;
+use tdlib_rs::types::{AvailableReaction, ReactionTypeEmoji};
+
+/// Менеджер реакций на сообщения.
+///
+/// Управляет добавлением, удалением и получением списка доступных
+/// реакций (emoji) для сообщений в чатах.
+///
+/// # Examples
+///
+/// ```ignore
+/// let reaction_manager = ReactionManager::new(client_id);
+///
+/// // Получить доступные реакции
+/// let reactions = reaction_manager.get_message_available_reactions(
+///     chat_id,
+///     message_id
+/// ).await?;
+///
+/// // Добавить/удалить реакцию
+/// reaction_manager.toggle_reaction(chat_id, message_id, "👍".to_string()).await?;
+/// ```
+pub struct ReactionManager {
+    /// ID клиента TDLib для API вызовов.
+    client_id: i32,
+}
+
+impl ReactionManager {
+    /// Создает новый менеджер реакций.
+    ///
+    /// # Arguments
+    ///
+    /// * `client_id` - ID клиента TDLib для API вызовов
+    pub fn new(client_id: i32) -> Self {
+        Self { client_id }
+    }
+
+    /// Получает список доступных реакций для сообщения.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `message_id` - ID сообщения
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Vec<String>)` - Список доступных emoji реакций
+    /// * `Err(String)` - Ошибка получения
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// let reactions = manager.get_message_available_reactions(
+    ///     ChatId::new(123),
+    ///     MessageId::new(456)
+    /// ).await?;
+    /// println!("Available: {:?}", reactions);
+    /// ```
+    pub async fn get_message_available_reactions(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+    ) -> Result<Vec<String>, String> {
+        // Получаем сообщение
+        let msg_result =
+            functions::get_message(chat_id.as_i64(), message_id.as_i64(), self.client_id).await;
+        let _msg = match msg_result {
+            Ok(m) => m,
+            Err(e) => return Err(format!("Ошибка получения сообщения: {:?}", e)),
+        };
+
+        // Получаем доступные реакции для чата
+        let reactions_result = functions::get_message_available_reactions(
+            chat_id.as_i64(),
+            message_id.as_i64(),
+            10, // row_size
+            self.client_id,
+        )
+        .await;
+
+        match reactions_result {
+            Ok(available) => {
+                let emojis = available_reaction_emojis(&available);
+                if emojis.is_empty() {
+                    Ok(default_reaction_emojis())
+                } else {
+                    Ok(emojis)
+                }
+            }
+            Err(_) => Ok(default_reaction_emojis()),
+        }
+    }
+
+    /// Переключает реакцию на сообщение (добавляет/удаляет).
+    ///
+    /// Сначала пытается добавить реакцию. Если не удалось (уже есть),
+    /// то удаляет её.
+    ///
+    /// # Arguments
+    ///
+    /// * `chat_id` - ID чата
+    /// * `message_id` - ID сообщения
+    /// * `emoji` - Emoji реакции (например, "👍", "❤️")
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Реакция переключена
+    /// * `Err(String)` - Ошибка переключения
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// // Добавить или удалить 👍
+    /// manager.toggle_reaction(chat_id, message_id, "👍".to_string()).await?;
+    /// ```
+    pub async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        emoji: String,
+    ) -> Result<(), String> {
+        let reaction = ReactionType::Emoji(ReactionTypeEmoji { emoji });
+
+        let result = functions::add_message_reaction(
+            chat_id.as_i64(),
+            message_id.as_i64(),
+            reaction.clone(),
+            false, // is_big
+            false, // update_recent_reactions
+            self.client_id,
+        )
+        .await;
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(_) => {
+                // Если добавление не удалось, пытаемся удалить
+                let remove_result = functions::remove_message_reaction(
+                    chat_id.as_i64(),
+                    message_id.as_i64(),
+                    reaction,
+                    self.client_id,
+                )
+                .await;
+                match remove_result {
+                    Ok(_) => Ok(()),
+                    Err(e) => Err(format!("Ошибка переключения реакции: {:?}", e)),
+                }
+            }
+        }
+    }
+}
+
+fn default_reaction_emojis() -> Vec<String> {
+    vec![
+        "👍".to_string(),
+        "👎".to_string(),
+        "❤️".to_string(),
+        "🔥".to_string(),
+        "😊".to_string(),
+        "😢".to_string(),
+        "😮".to_string(),
+        "🎉".to_string(),
+        "🤔".to_string(),
+        "😡".to_string(),
+        "😎".to_string(),
+        "🤝".to_string(),
+    ]
+}
+
+fn available_reaction_emojis(available: &AvailableReactions) -> Vec<String> {
+    let AvailableReactions::AvailableReactions(available) = available;
+
+    available
+        .top_reactions
+        .iter()
+        .chain(available.recent_reactions.iter())
+        .chain(available.popular_reactions.iter())
+        .filter_map(reaction_emoji)
+        .fold(Vec::new(), |mut emojis, emoji| {
+            if !emojis.contains(&emoji) {
+                emojis.push(emoji);
+            }
+            emojis
+        })
+}
+
+fn reaction_emoji(reaction: &AvailableReaction) -> Option<String> {
+    match &reaction.r#type {
+        ReactionType::Emoji(emoji) => Some(emoji.emoji.clone()),
+        ReactionType::CustomEmoji(_) => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tdlib_rs::types::{AvailableReaction, AvailableReactions as AvailableReactionsData};
+
+    fn emoji_reaction(emoji: &str) -> AvailableReaction {
+        AvailableReaction {
+            r#type: ReactionType::Emoji(ReactionTypeEmoji { emoji: emoji.to_string() }),
+            needs_premium: false,
+        }
+    }
+
+    #[test]
+    fn extracts_unique_emoji_reactions_in_display_order() {
+        let available = AvailableReactions::AvailableReactions(AvailableReactionsData {
+            top_reactions: vec![emoji_reaction("👍"), emoji_reaction("🔥")],
+            recent_reactions: vec![emoji_reaction("🔥"), emoji_reaction("❤️")],
+            popular_reactions: vec![emoji_reaction("🎉")],
+            allow_custom_emoji: false,
+            are_tags: false,
+            unavailability_reason: None,
+        });
+
+        assert_eq!(
+            available_reaction_emojis(&available),
+            vec![
+                "👍".to_string(),
+                "🔥".to_string(),
+                "❤️".to_string(),
+                "🎉".to_string(),
+            ]
+        );
+    }
+}

crates/tele-core/src/tdlib/trait.rs

@@ -0,0 +1,218 @@
+//! Trait definition for TdClient to enable dependency injection
+//!
+//! This trait allows tests to use FakeTdClient instead of real TDLib client.
+#![allow(dead_code)]
+
+use crate::tdlib::{
+    AuthState, FolderInfo, IncomingMessageEvent, MessageInfo, ProfileInfo, UserCache,
+    UserOnlineStatus,
+};
+use crate::types::{ChatId, MessageId, UserId};
+use async_trait::async_trait;
+use std::borrow::Cow;
+use std::path::PathBuf;
+use tdlib_rs::enums::{ChatAction, Update};
+
+use super::ChatInfo;
+
+/// Auth operations.
+#[async_trait]
+pub trait AuthClient: Send {
+    async fn send_phone_number(&self, phone: String) -> Result<(), String>;
+    async fn send_code(&self, code: String) -> Result<(), String>;
+    async fn send_password(&self, password: String) -> Result<(), String>;
+}
+
+/// Chat list and profile operations.
+#[async_trait]
+pub trait ChatClient: Send {
+    async fn load_chats(&mut self, limit: i32) -> Result<(), String>;
+    async fn load_folder_chats(&mut self, folder_id: i32, limit: i32) -> Result<(), String>;
+    async fn leave_chat(&self, chat_id: ChatId) -> Result<(), String>;
+    async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String>;
+
+    fn chats(&self) -> &[ChatInfo];
+    fn folders(&self) -> &[FolderInfo];
+    fn main_chat_list_position(&self) -> i32;
+    fn set_main_chat_list_position(&mut self, position: i32);
+    fn update_chats<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<ChatInfo>);
+    fn update_folders<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<FolderInfo>);
+}
+
+/// Ephemeral chat actions such as typing status.
+#[async_trait]
+pub trait ChatActionClient: Send {
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction);
+    fn clear_stale_typing_status(&mut self) -> bool;
+    fn typing_status(&self) -> Option<&(UserId, String, std::time::Instant)>;
+    fn set_typing_status(&mut self, status: Option<(UserId, String, std::time::Instant)>);
+}
+
+/// Message history, search, and mutation operations.
+#[async_trait]
+pub trait MessageClient: Send {
+    async fn get_chat_history(
+        &mut self,
+        chat_id: ChatId,
+        limit: i32,
+    ) -> Result<Vec<MessageInfo>, String>;
+    async fn load_older_messages(
+        &mut self,
+        chat_id: ChatId,
+        from_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String>;
+    async fn get_pinned_messages(&mut self, chat_id: ChatId) -> Result<Vec<MessageInfo>, String>;
+    async fn load_current_pinned_message(&mut self, chat_id: ChatId);
+    async fn search_messages(
+        &self,
+        chat_id: ChatId,
+        query: &str,
+    ) -> Result<Vec<MessageInfo>, String>;
+
+    async fn send_message(
+        &mut self,
+        chat_id: ChatId,
+        text: String,
+        reply_to_message_id: Option<MessageId>,
+        reply_info: Option<super::ReplyInfo>,
+    ) -> Result<MessageInfo, String>;
+
+    async fn edit_message(
+        &mut self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        new_text: String,
+    ) -> Result<MessageInfo, String>;
+
+    async fn delete_messages(
+        &mut self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String>;
+
+    async fn forward_messages(
+        &mut self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String>;
+
+    async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String>;
+
+    fn current_chat_messages(&self) -> Cow<'_, [MessageInfo]>;
+    fn current_chat_id(&self) -> Option<ChatId>;
+    fn current_pinned_message(&self) -> Option<MessageInfo>;
+    fn push_message(&mut self, msg: MessageInfo);
+    fn clear_current_chat_messages(&mut self);
+    fn set_current_chat_messages(&mut self, messages: Vec<MessageInfo>);
+    fn update_current_chat_messages<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<MessageInfo>);
+    fn set_current_chat_id(&mut self, chat_id: Option<ChatId>);
+    fn set_current_pinned_message(&mut self, msg: Option<MessageInfo>);
+    fn pending_view_messages(&self) -> &[(ChatId, Vec<MessageId>)];
+    fn enqueue_pending_view_messages(&mut self, chat_id: ChatId, message_ids: Vec<MessageId>);
+    async fn fetch_missing_reply_info(&mut self);
+    async fn process_pending_view_messages(&mut self);
+}
+
+/// User cache and user-status operations.
+#[async_trait]
+pub trait UserClient: Send {
+    fn get_user_status_by_chat_id(&self, chat_id: ChatId) -> Option<&UserOnlineStatus>;
+    fn pending_user_ids(&self) -> &[UserId];
+    fn user_cache(&self) -> &UserCache;
+    fn update_user_cache<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut UserCache);
+    async fn process_pending_user_ids(&mut self);
+}
+
+/// Message reaction operations.
+#[async_trait]
+pub trait ReactionClient: Send {
+    async fn get_message_available_reactions(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+    ) -> Result<Vec<String>, String>;
+
+    async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        reaction: String,
+    ) -> Result<(), String>;
+}
+
+/// File download operations.
+#[async_trait]
+pub trait FileClient: Send {
+    async fn download_file(&self, file_id: i32) -> Result<String, String>;
+    async fn download_voice_note(&self, file_id: i32) -> Result<String, String>;
+}
+
+/// Shared client state that does not belong to one feature area.
+#[async_trait]
+pub trait ClientState: Send {
+    fn client_id(&self) -> i32;
+    async fn get_me(&self) -> Result<i64, String>;
+    fn auth_state(&self) -> &AuthState;
+    fn network_state(&self) -> super::types::NetworkState;
+}
+
+/// Account switching operations.
+#[async_trait]
+pub trait AccountClient: Send {
+    /// Recreates the client with a new database path (for account switching).
+    ///
+    /// For real TdClient: closes old client, creates new one, inits TDLib parameters.
+    /// For FakeTdClient: no-op.
+    async fn recreate_client(&mut self, db_path: PathBuf) -> Result<(), String>;
+}
+
+/// TDLib update routing.
+pub trait UpdateClient: Send {
+    fn handle_update(&mut self, update: Update);
+    fn drain_incoming_message_events(&mut self) -> Vec<IncomingMessageEvent>;
+}
+
+/// Facade trait for TDLib client operations
+///
+/// This trait defines the interface for both real and fake TDLib clients,
+/// enabling dependency injection and easier testing.
+#[allow(dead_code)]
+pub trait TdClientTrait:
+    AuthClient
+    + ChatClient
+    + ChatActionClient
+    + MessageClient
+    + UserClient
+    + ReactionClient
+    + FileClient
+    + ClientState
+    + AccountClient
+    + UpdateClient
+    + Send
+{
+}
+
+impl<T> TdClientTrait for T where
+    T: AuthClient
+        + ChatClient
+        + ChatActionClient
+        + MessageClient
+        + UserClient
+        + ReactionClient
+        + FileClient
+        + ClientState
+        + AccountClient
+        + UpdateClient
+        + Send
+{
+}

crates/tele-core/src/tdlib/types.rs

@@ -0,0 +1,724 @@
+use tdlib_rs::enums::TextEntityType;
+use tdlib_rs::types::TextEntity;
+
+use crate::types::{ChatId, MessageId};
+
+#[derive(Debug, Clone)]
+pub struct ChatInfo {
+    pub id: ChatId,
+    pub title: String,
+    pub username: Option<String>,
+    pub last_message: String,
+    pub last_message_date: i32,
+    pub unread_count: i32,
+    /// Количество непрочитанных упоминаний (@)
+    pub unread_mention_count: i32,
+    pub is_pinned: bool,
+    pub order: i64,
+    /// ID последнего прочитанного исходящего сообщения (для галочек)
+    pub last_read_outbox_message_id: MessageId,
+    /// ID папок, в которых находится чат
+    pub folder_ids: Vec<i32>,
+    /// Чат замьючен (уведомления отключены)
+    pub is_muted: bool,
+    /// Черновик сообщения
+    pub draft_text: Option<String>,
+}
+
+/// Информация о сообщении, на которое отвечают
+#[derive(Debug, Clone)]
+pub struct ReplyInfo {
+    /// ID сообщения, на которое отвечают
+    pub message_id: MessageId,
+    /// Имя отправителя оригинального сообщения
+    pub sender_name: String,
+    /// Текст оригинального сообщения (превью)
+    pub text: String,
+}
+
+/// Информация о пересланном сообщении
+#[derive(Debug, Clone)]
+pub struct ForwardInfo {
+    /// Имя оригинального отправителя
+    pub sender_name: String,
+}
+
+/// Информация о реакции на сообщение
+#[derive(Debug, Clone)]
+pub struct ReactionInfo {
+    /// Эмодзи реакции (например, "👍")
+    pub emoji: String,
+    /// Количество людей, поставивших эту реакцию
+    pub count: i32,
+    /// Поставил ли текущий пользователь эту реакцию
+    pub is_chosen: bool,
+}
+
+/// Информация о медиа-контенте сообщения
+#[derive(Debug, Clone)]
+pub enum MediaInfo {
+    Photo(PhotoInfo),
+    Voice(VoiceInfo),
+}
+
+/// Информация о фотографии в сообщении
+#[derive(Debug, Clone)]
+pub struct PhotoInfo {
+    pub file_id: i32,
+    pub width: i32,
+    pub height: i32,
+    pub download_state: PhotoDownloadState,
+}
+
+/// Состояние загрузки фотографии
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub enum PhotoDownloadState {
+    NotDownloaded,
+    Downloading,
+    Downloaded(String),
+    Error(String),
+}
+
+/// Информация о голосовом сообщении
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub struct VoiceInfo {
+    pub file_id: i32,
+    pub duration: i32, // seconds
+    pub mime_type: String,
+    /// Waveform данные для визуализации (base64-encoded строка амплитуд)
+    pub waveform: String,
+    pub download_state: VoiceDownloadState,
+}
+
+/// Состояние загрузки голосового сообщения
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub enum VoiceDownloadState {
+    NotDownloaded,
+    Downloading,
+    Downloaded(String), // path to cached OGG file
+    Error(String),
+}
+
+/// Метаданные сообщения (ID, отправитель, время)
+#[derive(Debug, Clone)]
+pub struct MessageMetadata {
+    pub id: MessageId,
+    pub sender_name: String,
+    pub date: i32,
+    /// Дата редактирования (0 если не редактировалось)
+    pub edit_date: i32,
+    /// ID медиа-альбома (0 если не часть альбома)
+    pub media_album_id: i64,
+}
+
+/// Контент сообщения (текст и форматирование)
+#[derive(Debug, Clone)]
+pub struct MessageContent {
+    pub text: String,
+    /// Сущности форматирования (bold, italic, code и т.д.)
+    pub entities: Vec<TextEntity>,
+    /// Медиа-контент (фото, видео и т.д.)
+    pub media: Option<MediaInfo>,
+}
+
+/// Состояние и права доступа к сообщению
+#[derive(Debug, Clone)]
+pub struct MessageState {
+    pub is_outgoing: bool,
+    pub is_read: bool,
+    /// Можно ли редактировать сообщение
+    pub can_be_edited: bool,
+    /// Можно ли удалить только для себя
+    pub can_be_deleted_only_for_self: bool,
+    /// Можно ли удалить для всех
+    pub can_be_deleted_for_all_users: bool,
+}
+
+/// Взаимодействия с сообщением (reply, forward, reactions)
+#[derive(Debug, Clone)]
+pub struct MessageInteractions {
+    /// Информация о reply (если это ответ на сообщение)
+    pub reply_to: Option<ReplyInfo>,
+    /// Информация о forward (если сообщение переслано)
+    pub forward_from: Option<ForwardInfo>,
+    /// Реакции на сообщение
+    pub reactions: Vec<ReactionInfo>,
+}
+
+#[derive(Debug, Clone)]
+pub struct MessageInfo {
+    pub metadata: MessageMetadata,
+    pub content: MessageContent,
+    pub state: MessageState,
+    pub interactions: MessageInteractions,
+}
+
+impl MessageInfo {
+    /// Создать новое сообщение
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        id: MessageId,
+        sender_name: String,
+        is_outgoing: bool,
+        content: String,
+        entities: Vec<TextEntity>,
+        date: i32,
+        edit_date: i32,
+        is_read: bool,
+        can_be_edited: bool,
+        can_be_deleted_only_for_self: bool,
+        can_be_deleted_for_all_users: bool,
+        reply_to: Option<ReplyInfo>,
+        forward_from: Option<ForwardInfo>,
+        reactions: Vec<ReactionInfo>,
+    ) -> Self {
+        Self {
+            metadata: MessageMetadata {
+                id,
+                sender_name,
+                date,
+                edit_date,
+                media_album_id: 0,
+            },
+            content: MessageContent { text: content, entities, media: None },
+            state: MessageState {
+                is_outgoing,
+                is_read,
+                can_be_edited,
+                can_be_deleted_only_for_self,
+                can_be_deleted_for_all_users,
+            },
+            interactions: MessageInteractions { reply_to, forward_from, reactions },
+        }
+    }
+
+    // Удобные getter'ы для частых операций
+    pub fn id(&self) -> MessageId {
+        self.metadata.id
+    }
+
+    pub fn sender_name(&self) -> &str {
+        &self.metadata.sender_name
+    }
+
+    pub fn date(&self) -> i32 {
+        self.metadata.date
+    }
+
+    pub fn is_edited(&self) -> bool {
+        self.metadata.edit_date > 0
+    }
+
+    pub fn media_album_id(&self) -> i64 {
+        self.metadata.media_album_id
+    }
+
+    pub fn text(&self) -> &str {
+        &self.content.text
+    }
+
+    pub fn entities(&self) -> &[TextEntity] {
+        &self.content.entities
+    }
+
+    pub fn is_outgoing(&self) -> bool {
+        self.state.is_outgoing
+    }
+
+    pub fn is_read(&self) -> bool {
+        self.state.is_read
+    }
+
+    pub fn can_be_edited(&self) -> bool {
+        self.state.can_be_edited
+    }
+
+    pub fn can_be_deleted_only_for_self(&self) -> bool {
+        self.state.can_be_deleted_only_for_self
+    }
+
+    pub fn can_be_deleted_for_all_users(&self) -> bool {
+        self.state.can_be_deleted_for_all_users
+    }
+
+    /// Checks if the message contains a mention (@username or user mention)
+    pub fn has_mention(&self) -> bool {
+        self.content.entities.iter().any(|entity| {
+            matches!(entity.r#type, TextEntityType::Mention | TextEntityType::MentionName(_))
+        })
+    }
+
+    /// Проверяет, содержит ли сообщение фото
+    pub fn has_photo(&self) -> bool {
+        matches!(self.content.media, Some(MediaInfo::Photo(_)))
+    }
+
+    /// Возвращает ссылку на PhotoInfo (если есть)
+    pub fn photo_info(&self) -> Option<&PhotoInfo> {
+        match &self.content.media {
+            Some(MediaInfo::Photo(info)) => Some(info),
+            _ => None,
+        }
+    }
+
+    /// Возвращает мутабельную ссылку на PhotoInfo (если есть)
+    pub fn photo_info_mut(&mut self) -> Option<&mut PhotoInfo> {
+        match &mut self.content.media {
+            Some(MediaInfo::Photo(info)) => Some(info),
+            _ => None,
+        }
+    }
+
+    /// Проверяет, содержит ли сообщение голосовое
+    pub fn has_voice(&self) -> bool {
+        matches!(self.content.media, Some(MediaInfo::Voice(_)))
+    }
+
+    /// Возвращает ссылку на VoiceInfo (если есть)
+    pub fn voice_info(&self) -> Option<&VoiceInfo> {
+        match &self.content.media {
+            Some(MediaInfo::Voice(info)) => Some(info),
+            _ => None,
+        }
+    }
+
+    /// Возвращает мутабельную ссылку на VoiceInfo (если есть)
+    #[allow(dead_code)]
+    pub fn voice_info_mut(&mut self) -> Option<&mut VoiceInfo> {
+        match &mut self.content.media {
+            Some(MediaInfo::Voice(info)) => Some(info),
+            _ => None,
+        }
+    }
+
+    pub fn reply_to(&self) -> Option<&ReplyInfo> {
+        self.interactions.reply_to.as_ref()
+    }
+
+    pub fn forward_from(&self) -> Option<&ForwardInfo> {
+        self.interactions.forward_from.as_ref()
+    }
+
+    pub fn reactions(&self) -> &[ReactionInfo] {
+        &self.interactions.reactions
+    }
+}
+
+/// Builder для удобного создания MessageInfo с fluent API
+///
+/// # Примеры
+///
+/// ```
+/// use tele_core::tdlib::MessageBuilder;
+/// use tele_core::types::MessageId;
+///
+/// let message = MessageBuilder::new(MessageId::new(123))
+///     .sender_name("Alice")
+///     .text("Hello, world!")
+///     .outgoing()
+///     .date(1640000000)
+///     .build();
+/// ```
+pub struct MessageBuilder {
+    id: MessageId,
+    sender_name: String,
+    is_outgoing: bool,
+    text: String,
+    entities: Vec<TextEntity>,
+    date: i32,
+    edit_date: i32,
+    is_read: bool,
+    can_be_edited: bool,
+    can_be_deleted_only_for_self: bool,
+    can_be_deleted_for_all_users: bool,
+    reply_to: Option<ReplyInfo>,
+    forward_from: Option<ForwardInfo>,
+    reactions: Vec<ReactionInfo>,
+    media: Option<MediaInfo>,
+    media_album_id: i64,
+}
+
+impl MessageBuilder {
+    /// Создать новый builder с обязательным ID сообщения
+    pub fn new(id: MessageId) -> Self {
+        Self {
+            id,
+            sender_name: String::new(),
+            is_outgoing: false,
+            text: String::new(),
+            entities: Vec::new(),
+            date: 0,
+            edit_date: 0,
+            is_read: false,
+            can_be_edited: false,
+            can_be_deleted_only_for_self: true,
+            can_be_deleted_for_all_users: false,
+            reply_to: None,
+            forward_from: None,
+            reactions: Vec::new(),
+            media: None,
+            media_album_id: 0,
+        }
+    }
+
+    /// Установить имя отправителя
+    pub fn sender_name(mut self, name: impl Into<String>) -> Self {
+        self.sender_name = name.into();
+        self
+    }
+
+    /// Пометить сообщение как исходящее
+    pub fn outgoing(mut self) -> Self {
+        self.is_outgoing = true;
+        self.can_be_edited = true;
+        self.can_be_deleted_for_all_users = true;
+        self
+    }
+
+    /// Пометить сообщение как входящее
+    pub fn incoming(mut self) -> Self {
+        self.is_outgoing = false;
+        self.can_be_edited = false;
+        self.can_be_deleted_for_all_users = false;
+        self
+    }
+
+    /// Установить текст сообщения
+    pub fn text(mut self, text: impl Into<String>) -> Self {
+        self.text = text.into();
+        self
+    }
+
+    /// Установить entities для форматирования
+    pub fn entities(mut self, entities: Vec<TextEntity>) -> Self {
+        self.entities = entities;
+        self
+    }
+
+    /// Установить дату сообщения (unix timestamp)
+    pub fn date(mut self, date: i32) -> Self {
+        self.date = date;
+        self
+    }
+
+    /// Установить дату редактирования (unix timestamp)
+    pub fn edit_date(mut self, edit_date: i32) -> Self {
+        self.edit_date = edit_date;
+        self
+    }
+
+    /// Пометить сообщение как прочитанное
+    pub fn read(mut self) -> Self {
+        self.is_read = true;
+        self
+    }
+
+    /// Пометить сообщение как непрочитанное
+    pub fn unread(mut self) -> Self {
+        self.is_read = false;
+        self
+    }
+
+    /// Разрешить редактирование
+    pub fn editable(mut self) -> Self {
+        self.can_be_edited = true;
+        self
+    }
+
+    /// Разрешить удаление только для себя
+    pub fn deletable_for_self(mut self) -> Self {
+        self.can_be_deleted_only_for_self = true;
+        self
+    }
+
+    /// Разрешить удаление для всех
+    pub fn deletable_for_all(mut self) -> Self {
+        self.can_be_deleted_for_all_users = true;
+        self
+    }
+
+    /// Установить информацию об ответе
+    pub fn reply_to(mut self, reply: ReplyInfo) -> Self {
+        self.reply_to = Some(reply);
+        self
+    }
+
+    /// Установить информацию о пересылке
+    pub fn forward_from(mut self, forward: ForwardInfo) -> Self {
+        self.forward_from = Some(forward);
+        self
+    }
+
+    /// Установить реакции
+    pub fn reactions(mut self, reactions: Vec<ReactionInfo>) -> Self {
+        self.reactions = reactions;
+        self
+    }
+
+    /// Установить медиа-контент
+    pub fn media(mut self, media: MediaInfo) -> Self {
+        self.media = Some(media);
+        self
+    }
+
+    /// Установить ID медиа-альбома
+    pub fn media_album_id(mut self, id: i64) -> Self {
+        self.media_album_id = id;
+        self
+    }
+
+    /// Построить MessageInfo из данных builder'а
+    pub fn build(self) -> MessageInfo {
+        let mut msg = MessageInfo::new(
+            self.id,
+            self.sender_name,
+            self.is_outgoing,
+            self.text,
+            self.entities,
+            self.date,
+            self.edit_date,
+            self.is_read,
+            self.can_be_edited,
+            self.can_be_deleted_only_for_self,
+            self.can_be_deleted_for_all_users,
+            self.reply_to,
+            self.forward_from,
+            self.reactions,
+        );
+        msg.content.media = self.media;
+        msg.metadata.media_album_id = self.media_album_id;
+        msg
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::MessageId;
+
+    #[test]
+    fn test_message_builder_basic() {
+        let message = MessageBuilder::new(MessageId::new(123))
+            .sender_name("Alice")
+            .text("Hello, world!")
+            .date(1640000000)
+            .build();
+
+        assert_eq!(message.id(), MessageId::new(123));
+        assert_eq!(message.sender_name(), "Alice");
+        assert_eq!(message.text(), "Hello, world!");
+        assert_eq!(message.date(), 1640000000);
+        assert!(!message.is_outgoing());
+    }
+
+    #[test]
+    fn test_message_builder_outgoing() {
+        let message = MessageBuilder::new(MessageId::new(456))
+            .sender_name("Me")
+            .text("Test message")
+            .outgoing()
+            .read()
+            .build();
+
+        assert!(message.is_outgoing());
+        assert!(message.is_read());
+        assert!(message.can_be_edited());
+        assert!(message.can_be_deleted_for_all_users());
+    }
+
+    #[test]
+    fn test_message_builder_edited() {
+        let message = MessageBuilder::new(MessageId::new(789))
+            .text("Original text")
+            .date(1640000000)
+            .edit_date(1640000060)
+            .build();
+
+        assert!(message.is_edited());
+        assert_eq!(message.metadata.edit_date, 1640000060);
+    }
+
+    #[test]
+    fn test_message_builder_with_reply() {
+        let reply = ReplyInfo {
+            message_id: MessageId::new(100),
+            sender_name: "Bob".to_string(),
+            text: "Original message".to_string(),
+        };
+
+        let message = MessageBuilder::new(MessageId::new(200))
+            .text("Reply text")
+            .reply_to(reply)
+            .build();
+
+        assert!(message.reply_to().is_some());
+        assert_eq!(message.reply_to().unwrap().sender_name, "Bob");
+    }
+
+    #[test]
+    fn test_message_builder_with_reactions() {
+        let reaction = ReactionInfo {
+            emoji: "👍".to_string(), count: 5, is_chosen: true
+        };
+
+        let message = MessageBuilder::new(MessageId::new(300))
+            .text("Cool message")
+            .reactions(vec![reaction.clone()])
+            .build();
+
+        assert_eq!(message.reactions().len(), 1);
+        assert_eq!(message.reactions()[0].emoji, "👍");
+        assert_eq!(message.reactions()[0].count, 5);
+    }
+
+    #[test]
+    fn test_message_builder_fluent_api() {
+        let message = MessageBuilder::new(MessageId::new(999))
+            .sender_name("Charlie")
+            .text("Complex message")
+            .date(1640000000)
+            .outgoing()
+            .read()
+            .editable()
+            .deletable_for_all()
+            .build();
+
+        assert_eq!(message.sender_name(), "Charlie");
+        assert_eq!(message.text(), "Complex message");
+        assert!(message.is_outgoing());
+        assert!(message.is_read());
+        assert!(message.can_be_edited());
+        assert!(message.can_be_deleted_for_all_users());
+    }
+
+    #[test]
+    fn test_message_has_mention() {
+        // Message without mentions
+        let message = MessageBuilder::new(MessageId::new(1))
+            .text("Hello world")
+            .build();
+        assert!(!message.has_mention());
+
+        // Message with @mention
+        let message_with_mention = MessageBuilder::new(MessageId::new(2))
+            .text("Hello @user")
+            .entities(vec![TextEntity {
+                offset: 6,
+                length: 5,
+                r#type: TextEntityType::Mention,
+            }])
+            .build();
+        assert!(message_with_mention.has_mention());
+
+        // Message with MentionName
+        let message_with_mention_name = MessageBuilder::new(MessageId::new(3))
+            .text("Hello John")
+            .entities(vec![TextEntity {
+                offset: 6,
+                length: 4,
+                r#type: TextEntityType::MentionName(tdlib_rs::types::TextEntityTypeMentionName {
+                    user_id: 123,
+                }),
+            }])
+            .build();
+        assert!(message_with_mention_name.has_mention());
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FolderInfo {
+    pub id: i32,
+    pub name: String,
+}
+
+/// Информация о профиле чата/пользователя
+#[derive(Debug, Clone)]
+pub struct ProfileInfo {
+    pub chat_id: ChatId,
+    pub title: String,
+    pub username: Option<String>,
+    pub bio: Option<String>,
+    pub phone_number: Option<String>,
+    pub chat_type: String, // "Личный чат", "Группа", "Канал"
+    pub member_count: Option<i32>,
+    pub description: Option<String>,
+    pub invite_link: Option<String>,
+    pub is_group: bool,
+    pub online_status: Option<String>,
+}
+
+/// Состояние сетевого соединения
+#[derive(Debug, Clone, PartialEq)]
+pub enum NetworkState {
+    /// Ожидание подключения к сети
+    WaitingForNetwork,
+    /// Подключение к прокси
+    ConnectingToProxy,
+    /// Подключение к серверам Telegram
+    Connecting,
+    /// Обновление данных
+    Updating,
+    /// Подключено
+    Ready,
+}
+
+/// Онлайн-статус пользователя
+#[derive(Debug, Clone, PartialEq)]
+pub enum UserOnlineStatus {
+    /// Онлайн
+    Online,
+    /// Был недавно (менее часа назад)
+    Recently,
+    /// Был на этой неделе
+    LastWeek,
+    /// Был в этом месяце
+    LastMonth,
+    /// Давно не был
+    LongTimeAgo,
+    /// Оффлайн с указанием времени (unix timestamp)
+    Offline(i32),
+}
+
+/// Состояние модального окна для просмотра изображения
+#[cfg(feature = "images")]
+#[derive(Debug, Clone)]
+pub struct ImageModalState {
+    /// ID сообщения с фото
+    pub message_id: MessageId,
+    /// Путь к файлу изображения
+    pub photo_path: String,
+    /// Ширина оригинального изображения
+    pub photo_width: i32,
+    /// Высота оригинального изображения
+    pub photo_height: i32,
+}
+
+/// Состояние воспроизведения голосового сообщения
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub struct PlaybackState {
+    /// ID сообщения, которое воспроизводится
+    pub message_id: MessageId,
+    /// Статус воспроизведения
+    pub status: PlaybackStatus,
+    /// Текущая позиция (секунды)
+    pub position: f32,
+    /// Общая длительность (секунды)
+    pub duration: f32,
+    /// Громкость (0.0 - 1.0)
+    pub volume: f32,
+}
+
+/// Статус воспроизведения
+#[allow(dead_code)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum PlaybackStatus {
+    Playing,
+    Paused,
+    Stopped,
+    Loading,
+    Error(String),
+}

crates/tele-core/src/tdlib/update_handlers.rs

@@ -0,0 +1,324 @@
+//! Update handlers for TDLib events.
+//!
+//! This module contains functions that process various types of updates from TDLib.
+//! Each handler is responsible for updating the application state based on the received update.
+
+use crate::types::{ChatId, MessageId, UserId};
+use std::time::Instant;
+use tdlib_rs::enums::{AuthorizationState, ChatAction, ChatList, MessageSender};
+use tdlib_rs::types::{
+    UpdateChatAction, UpdateChatDraftMessage, UpdateChatPosition, UpdateMessageInteractionInfo,
+    UpdateMessageSendSucceeded, UpdateNewMessage, UpdateUser,
+};
+
+use super::auth::AuthState;
+use super::client::TdClient;
+use super::types::ReactionInfo;
+
+/// Обрабатывает Update::NewMessage - добавление нового сообщения
+pub fn handle_new_message_update(client: &mut TdClient, new_msg: UpdateNewMessage) {
+    let chat_id = ChatId::new(new_msg.message.chat_id);
+
+    // Если сообщение НЕ для текущего открытого чата - отправляем уведомление
+    if Some(chat_id) != client.current_chat_id() {
+        // Find and clone chat info to avoid borrow checker issues
+        if let Some(chat) = client.chats().iter().find(|c| c.id == chat_id).cloned() {
+            let msg_info =
+                crate::tdlib::message_converter::convert_message(client, &new_msg.message, chat_id);
+
+            // Get sender name (from message or user cache)
+            let sender_name = msg_info.sender_name().to_string();
+
+            client.enqueue_incoming_message_event(chat, msg_info, sender_name);
+        }
+        return;
+    }
+
+    // Добавляем новое сообщение если это текущий открытый чат
+
+    let msg_info =
+        crate::tdlib::message_converter::convert_message(client, &new_msg.message, chat_id);
+    let msg_id = msg_info.id();
+    let is_incoming = !msg_info.is_outgoing();
+
+    // Проверяем, есть ли уже сообщение с таким id
+    let existing_idx = client
+        .current_chat_messages()
+        .iter()
+        .position(|m| m.id() == msg_info.id());
+
+    match existing_idx {
+        Some(idx) => {
+            // Сообщение уже есть - обновляем
+            if is_incoming {
+                client.replace_current_chat_message(msg_id, msg_info);
+            } else {
+                // Для исходящих: обновляем can_be_edited и другие поля,
+                // но сохраняем reply_to (добавленный при отправке)
+                client.update_current_chat_messages(|messages| {
+                    let existing = &mut messages[idx];
+                    existing.state.can_be_edited = msg_info.state.can_be_edited;
+                    existing.state.can_be_deleted_only_for_self =
+                        msg_info.state.can_be_deleted_only_for_self;
+                    existing.state.can_be_deleted_for_all_users =
+                        msg_info.state.can_be_deleted_for_all_users;
+                    existing.state.is_read = msg_info.state.is_read;
+                });
+            }
+        }
+        None => {
+            // Нового сообщения нет - добавляем
+            client.push_message(msg_info.clone());
+            // Если это входящее сообщение — добавляем в очередь для отметки как прочитанное
+            if is_incoming {
+                client.enqueue_pending_view_messages(chat_id, vec![msg_id]);
+            }
+        }
+    }
+}
+
+/// Обрабатывает Update::ChatAction - статус набора текста/отправки файлов
+pub fn handle_chat_action_update(client: &mut TdClient, update: UpdateChatAction) {
+    // Обрабатываем только для текущего открытого чата
+    if Some(ChatId::new(update.chat_id)) != client.current_chat_id() {
+        return;
+    }
+
+    // Извлекаем user_id из sender_id
+    let MessageSender::User(user) = update.sender_id else {
+        return; // Игнорируем действия от имени чата
+    };
+    let user_id = UserId::new(user.user_id);
+
+    // Определяем текст действия
+    let action_text = match update.action {
+        ChatAction::Typing => Some("печатает...".to_string()),
+        ChatAction::RecordingVideo => Some("записывает видео...".to_string()),
+        ChatAction::UploadingVideo(_) => Some("отправляет видео...".to_string()),
+        ChatAction::RecordingVoiceNote => Some("записывает голосовое...".to_string()),
+        ChatAction::UploadingVoiceNote(_) => Some("отправляет голосовое...".to_string()),
+        ChatAction::UploadingPhoto(_) => Some("отправляет фото...".to_string()),
+        ChatAction::UploadingDocument(_) => Some("отправляет файл...".to_string()),
+        ChatAction::ChoosingSticker => Some("выбирает стикер...".to_string()),
+        ChatAction::RecordingVideoNote => Some("записывает видеосообщение...".to_string()),
+        ChatAction::UploadingVideoNote(_) => Some("отправляет видеосообщение...".to_string()),
+        _ => None, // Отмена или неизвестное действие
+    };
+
+    match action_text {
+        Some(text) => client.set_typing_status(Some((user_id, text, Instant::now()))),
+        None => client.set_typing_status(None),
+    }
+}
+
+/// Обрабатывает Update::ChatPosition - изменение позиции чата в списке.
+///
+/// Обновляет order и is_pinned для чатов в Main списке,
+/// управляет folder_ids для чатов в папках.
+pub fn handle_chat_position_update(client: &mut TdClient, update: UpdateChatPosition) {
+    let chat_id = ChatId::new(update.chat_id);
+    match &update.position.list {
+        ChatList::Main => {
+            if update.position.order == 0 {
+                // Чат больше не в Main (перемещён в архив и т.д.)
+                client.remove_chat(chat_id);
+            } else {
+                // Обновляем позицию существующего чата
+                crate::tdlib::chat_helpers::update_chat(client, chat_id, |chat| {
+                    chat.order = update.position.order;
+                    chat.is_pinned = update.position.is_pinned;
+                });
+            }
+            // Пересортируем по order
+            client.sort_chats_by_order();
+        }
+        ChatList::Folder(folder) => {
+            // Обновляем folder_ids для чата
+            crate::tdlib::chat_helpers::update_chat(client, chat_id, |chat| {
+                if update.position.order == 0 {
+                    // Чат удалён из папки
+                    chat.folder_ids.retain(|&id| id != folder.chat_folder_id);
+                } else {
+                    // Чат добавлен в папку
+                    if !chat.folder_ids.contains(&folder.chat_folder_id) {
+                        chat.folder_ids.push(folder.chat_folder_id);
+                    }
+                }
+            });
+        }
+        ChatList::Archive => {
+            // Архив пока не обрабатываем
+        }
+    }
+}
+
+/// Обрабатывает Update::User - обновление информации о пользователе.
+///
+/// Сохраняет display name и username в кэше,
+/// обновляет username в связанных чатах,
+/// удаляет "Deleted Account" из списка чатов.
+pub fn handle_user_update(client: &mut TdClient, update: UpdateUser) {
+    let user = update.user;
+
+    // Пропускаем удалённые аккаунты (пустое имя)
+    if user.first_name.is_empty() && user.last_name.is_empty() {
+        // Удаляем чаты с этим пользователем из списка
+        let user_id = user.id;
+        // Clone chat_user_ids to avoid borrow conflict
+        let chat_user_ids = client.user_cache().chat_user_ids.clone();
+        client.update_chats(|chats| {
+            chats.retain(|c| chat_user_ids.get(&c.id) != Some(&UserId::new(user_id)));
+        });
+        return;
+    }
+
+    // Сохраняем display name (first_name + last_name)
+    let display_name = if user.last_name.is_empty() {
+        user.first_name.clone()
+    } else {
+        format!("{} {}", user.first_name, user.last_name)
+    };
+    client.update_user_cache(|cache| {
+        cache.user_names.insert(UserId::new(user.id), display_name);
+    });
+
+    // Сохраняем username если есть (с упрощённым извлечением через and_then)
+    if let Some(username) = user
+        .usernames
+        .as_ref()
+        .and_then(|u| u.active_usernames.first())
+    {
+        let affected_chat_ids = client.update_user_cache(|cache| {
+            cache
+                .user_usernames
+                .insert(UserId::new(user.id), username.to_string());
+            cache
+                .chat_user_ids
+                .iter()
+                .filter_map(|(&chat_id, &user_id)| {
+                    (user_id == UserId::new(user.id)).then_some(chat_id)
+                })
+                .collect::<Vec<_>>()
+        });
+        // Обновляем username в чатах, связанных с этим пользователем
+        for chat_id in affected_chat_ids {
+            crate::tdlib::chat_helpers::update_chat(client, chat_id, |chat| {
+                chat.username = Some(format!("@{}", username));
+            });
+        }
+    }
+    // LRU-кэш автоматически удаляет старые записи при вставке
+}
+
+/// Обрабатывает Update::MessageInteractionInfo - обновление реакций на сообщение.
+///
+/// Обновляет список реакций для сообщения в текущем открытом чате.
+pub fn handle_message_interaction_info_update(
+    client: &mut TdClient,
+    update: UpdateMessageInteractionInfo,
+) {
+    // Обновляем реакции в текущем открытом чате
+    if Some(ChatId::new(update.chat_id)) != client.current_chat_id() {
+        return;
+    }
+
+    // Извлекаем реакции из interaction_info
+    let reactions = update
+        .interaction_info
+        .as_ref()
+        .and_then(|info| info.reactions.as_ref())
+        .map(|reactions| {
+            reactions
+                .reactions
+                .iter()
+                .filter_map(|reaction| {
+                    let emoji = match &reaction.r#type {
+                        tdlib_rs::enums::ReactionType::Emoji(e) => e.emoji.clone(),
+                        tdlib_rs::enums::ReactionType::CustomEmoji(_) => return None,
+                    };
+
+                    Some(ReactionInfo {
+                        emoji,
+                        count: reaction.total_count,
+                        is_chosen: reaction.is_chosen,
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    client.update_current_chat_message(MessageId::new(update.message_id), |msg| {
+        msg.interactions.reactions = reactions;
+    });
+}
+
+/// Обрабатывает Update::MessageSendSucceeded - успешная отправка сообщения.
+///
+/// Заменяет временный ID сообщения на настоящий ID от сервера,
+/// сохраняя reply_info из временного сообщения.
+pub fn handle_message_send_succeeded_update(
+    client: &mut TdClient,
+    update: UpdateMessageSendSucceeded,
+) {
+    let old_id = MessageId::new(update.old_message_id);
+    let chat_id = ChatId::new(update.message.chat_id);
+
+    // Обрабатываем только если это текущий открытый чат
+    if Some(chat_id) != client.current_chat_id() {
+        return;
+    }
+
+    // Находим сообщение с временным ID
+    let Some(idx) = client
+        .current_chat_messages()
+        .iter()
+        .position(|m| m.id() == old_id)
+    else {
+        return;
+    };
+
+    // Конвертируем новое сообщение
+    let mut new_msg =
+        crate::tdlib::message_converter::convert_message(client, &update.message, chat_id);
+
+    // Сохраняем reply_info из старого сообщения (если было)
+    let old_reply = client.current_chat_messages()[idx]
+        .interactions
+        .reply_to
+        .clone();
+    if let Some(reply) = old_reply {
+        new_msg.interactions.reply_to = Some(reply);
+    }
+
+    // Заменяем старое сообщение на новое
+    client.replace_current_chat_message(old_id, new_msg);
+}
+
+/// Обрабатывает Update::ChatDraftMessage - обновление черновика сообщения в чате.
+///
+/// Извлекает текст черновика и сохраняет его в ChatInfo для отображения в списке чатов.
+pub fn handle_chat_draft_message_update(client: &mut TdClient, update: UpdateChatDraftMessage) {
+    crate::tdlib::chat_helpers::update_chat(client, ChatId::new(update.chat_id), |chat| {
+        chat.draft_text = update.draft_message.as_ref().and_then(|draft| {
+            // Извлекаем текст из InputMessageText с помощью pattern matching
+            match &draft.input_message_text {
+                tdlib_rs::enums::InputMessageContent::InputMessageText(text_msg) => {
+                    Some(text_msg.text.text.clone())
+                }
+                _ => None,
+            }
+        });
+    });
+}
+
+/// Обрабатывает изменение состояния авторизации
+pub fn handle_auth_state(client: &mut TdClient, state: AuthorizationState) {
+    client.auth.state = match state {
+        AuthorizationState::WaitTdlibParameters => AuthState::WaitTdlibParameters,
+        AuthorizationState::WaitPhoneNumber => AuthState::WaitPhoneNumber,
+        AuthorizationState::WaitCode(_) => AuthState::WaitCode,
+        AuthorizationState::WaitPassword(_) => AuthState::WaitPassword,
+        AuthorizationState::Ready => AuthState::Ready,
+        AuthorizationState::Closed => AuthState::Closed,
+        _ => client.auth.state.clone(),
+    };
+}

crates/tele-core/src/tdlib/users.rs

@@ -0,0 +1,270 @@
+use crate::constants::{LAZY_LOAD_USERS_PER_TICK, MAX_CHAT_USER_IDS, MAX_USER_CACHE_SIZE};
+use crate::types::{ChatId, UserId};
+use std::collections::HashMap;
+use tdlib_rs::enums::{User, UserStatus};
+use tdlib_rs::functions;
+
+use super::types::UserOnlineStatus;
+
+/// LRU (Least Recently Used) кэш с фиксированной ёмкостью.
+///
+/// Автоматически удаляет самые давно использованные элементы при достижении лимита.
+/// Основан на HashMap для быстрого доступа и Vec для отслеживания порядка использования.
+///
+/// # Type Parameters
+///
+/// * `K` - Тип ключа (должен реализовывать `Eq + Hash + Clone + Copy`)
+/// * `V` - Тип значения (должен реализовывать `Clone`)
+///
+/// # Examples
+///
+/// ```ignore
+/// let mut cache = LruCache::<UserId, String>::new(100);
+/// cache.insert(UserId::new(1), "Alice".to_string());
+/// assert_eq!(cache.get(&UserId::new(1)), Some(&"Alice".to_string()));
+/// ```
+pub struct LruCache<K, V> {
+    /// Хранилище ключ-значение.
+    map: HashMap<K, V>,
+
+    /// Порядок доступа: последний элемент — самый недавно использованный.
+    order: Vec<K>,
+
+    /// Максимальная ёмкость кэша.
+    capacity: usize,
+}
+
+impl<K, V> LruCache<K, V>
+where
+    K: Eq + std::hash::Hash + Clone + Copy,
+    V: Clone,
+{
+    /// Создает новый LRU кэш с заданной ёмкостью.
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            map: HashMap::with_capacity(capacity),
+            order: Vec::with_capacity(capacity),
+            capacity,
+        }
+    }
+
+    /// Получает значение и обновляет порядок доступа (помечает как использованное).
+    pub fn get(&mut self, key: &K) -> Option<&V> {
+        if self.map.contains_key(key) {
+            // Перемещаем ключ в конец (самый недавно использованный)
+            self.order.retain(|k| k != key);
+            self.order.push(*key);
+            self.map.get(key)
+        } else {
+            None
+        }
+    }
+
+    /// Получить значение без обновления порядка (для read-only доступа)
+    pub fn peek(&self, key: &K) -> Option<&V> {
+        self.map.get(key)
+    }
+
+    /// Вставить значение
+    pub fn insert(&mut self, key: K, value: V) {
+        if self.map.contains_key(&key) {
+            // Обновляем существующее значение
+            self.map.insert(key, value);
+            self.order.retain(|k| *k != key);
+            self.order.push(key);
+        } else {
+            // Если кэш полон, удаляем самый старый элемент
+            if self.map.len() >= self.capacity {
+                if let Some(oldest) = self.order.first().copied() {
+                    self.order.remove(0);
+                    self.map.remove(&oldest);
+                }
+            }
+            self.map.insert(key, value);
+            self.order.push(key);
+        }
+    }
+
+    /// Проверить наличие ключа
+    pub fn contains_key(&self, key: &K) -> bool {
+        self.map.contains_key(key)
+    }
+}
+
+/// Кэш информации о пользователях Telegram.
+///
+/// Хранит данные пользователей (имена, usernames, статусы) в LRU-кэшах
+/// для быстрого доступа без повторных запросов к TDLib.
+///
+/// # Возможности
+///
+/// - Кэширование имен пользователей (first_name + last_name)
+/// - Кэширование usernames (@username)
+/// - Кэширование онлайн-статусов
+/// - Связь chat_id → user_id для приватных чатов
+/// - Ленивая загрузка данных пользователей порциями
+///
+/// # Examples
+///
+/// ```ignore
+/// let mut cache = UserCache::new(client_id);
+///
+/// // Обработать обновление пользователя
+/// cache.handle_user_update(&user_enum);
+///
+/// // Получить имя
+/// let name = cache.get_user_name(user_id).await;
+/// ```
+pub struct UserCache {
+    /// LRU-кэш usernames: user_id → username.
+    pub user_usernames: LruCache<UserId, String>,
+
+    /// LRU-кэш имён: user_id → display_name (first_name + last_name).
+    pub user_names: LruCache<UserId, String>,
+
+    /// Связь chat_id → user_id для приватных чатов.
+    pub chat_user_ids: HashMap<ChatId, UserId>,
+
+    /// Очередь user_id для ленивой загрузки имён.
+    pub pending_user_ids: Vec<UserId>,
+
+    /// LRU-кэш онлайн-статусов: user_id → status.
+    pub user_statuses: LruCache<UserId, UserOnlineStatus>,
+
+    /// ID клиента TDLib для API вызовов.
+    client_id: i32,
+}
+
+impl UserCache {
+    /// Создает новый кэш пользователей.
+    ///
+    /// # Arguments
+    ///
+    /// * `client_id` - ID клиента TDLib для API вызовов
+    pub fn new(client_id: i32) -> Self {
+        Self {
+            user_usernames: LruCache::new(MAX_USER_CACHE_SIZE),
+            user_names: LruCache::new(MAX_USER_CACHE_SIZE),
+            chat_user_ids: HashMap::with_capacity(MAX_CHAT_USER_IDS),
+            pending_user_ids: Vec::new(),
+            user_statuses: LruCache::new(MAX_USER_CACHE_SIZE),
+            client_id,
+        }
+    }
+
+    /// Получить статус пользователя по chat_id
+    pub fn get_status_by_chat_id(&self, chat_id: ChatId) -> Option<&UserOnlineStatus> {
+        let user_id = self.chat_user_ids.get(&chat_id)?;
+        self.user_statuses.peek(user_id)
+    }
+
+    /// Обрабатывает обновление пользователя от TDLib.
+    ///
+    /// Сохраняет username, имя и статус пользователя в соответствующие кэши.
+    ///
+    /// # Arguments
+    ///
+    /// * `user_enum` - Обновление пользователя от TDLib
+    pub fn handle_user_update(&mut self, user_enum: &User) {
+        let User::User(user) = user_enum;
+        let user_id = user.id;
+
+        // Сохраняем username
+        if let Some(username) = user.usernames.as_ref().map(|u| u.editable_username.clone()) {
+            self.user_usernames.insert(UserId::new(user_id), username);
+        }
+
+        // Сохраняем имя
+        let display_name = format!("{} {}", user.first_name, user.last_name)
+            .trim()
+            .to_string();
+        self.user_names.insert(UserId::new(user_id), display_name);
+
+        // Обновляем статус
+        self.update_status(UserId::new(user_id), &user.status);
+    }
+
+    /// Обновляет онлайн-статус пользователя.
+    ///
+    /// # Arguments
+    ///
+    /// * `user_id` - ID пользователя
+    /// * `status` - Новый статус от TDLib
+    pub fn update_status(&mut self, user_id: UserId, status: &UserStatus) {
+        let online_status = match status {
+            UserStatus::Online(_) => UserOnlineStatus::Online,
+            UserStatus::Recently(_) => UserOnlineStatus::Recently,
+            UserStatus::LastWeek(_) => UserOnlineStatus::LastWeek,
+            UserStatus::LastMonth(_) => UserOnlineStatus::LastMonth,
+            UserStatus::Offline(s) => UserOnlineStatus::Offline(s.was_online),
+            _ => return,
+        };
+        self.user_statuses.insert(user_id, online_status);
+    }
+
+    /// Получает имя пользователя из кэша или загружает из TDLib.
+    ///
+    /// Сначала проверяет кэш, затем при необходимости загружает из API.
+    ///
+    /// # Arguments
+    ///
+    /// * `user_id` - ID пользователя
+    ///
+    /// # Returns
+    ///
+    /// Имя пользователя (first_name + last_name) или "User {id}" если не найден.
+    #[allow(dead_code)]
+    pub async fn get_user_name(&self, user_id: UserId) -> String {
+        // Сначала пытаемся получить из кэша
+        if let Some(name) = self.user_names.peek(&user_id) {
+            return name.clone();
+        }
+
+        // Загружаем пользователя
+        match functions::get_user(user_id.as_i64(), self.client_id).await {
+            Ok(User::User(user)) => {
+                let name = format!("{} {}", user.first_name, user.last_name)
+                    .trim()
+                    .to_string();
+                name
+            }
+            _ => format!("User {}", user_id.as_i64()),
+        }
+    }
+
+    /// Обрабатывает очередь отложенных user_ids для ленивой загрузки.
+    ///
+    /// Загружает данные пользователей небольшими порциями (по [`LAZY_LOAD_USERS_PER_TICK`])
+    /// для избежания блокировки UI.
+    ///
+    /// # Note
+    ///
+    /// Вызывайте периодически в основном цикле приложения.
+    pub async fn process_pending_user_ids(&mut self) {
+        if self.pending_user_ids.is_empty() {
+            return;
+        }
+
+        // Берём первые N user_ids для загрузки
+        let batch: Vec<UserId> = self
+            .pending_user_ids
+            .drain(..self.pending_user_ids.len().min(LAZY_LOAD_USERS_PER_TICK))
+            .collect();
+
+        for user_id in batch {
+            if self.user_names.contains_key(&user_id) {
+                continue; // Уже в кэше
+            }
+
+            match functions::get_user(user_id.as_i64(), self.client_id).await {
+                Ok(user_enum) => {
+                    self.handle_user_update(&user_enum);
+                }
+                Err(_) => {
+                    // Если не удалось загрузить, сохраняем placeholder
+                    self.user_names.insert(user_id, format!("User {}", user_id));
+                }
+            }
+        }
+    }
+}

crates/tele-core/src/test_support/fake_tdclient.rs

@@ -0,0 +1,12 @@
+// Fake TDLib client for testing.
+
+mod builders;
+mod inspect;
+mod operations;
+mod state;
+
+#[allow(unused_imports)]
+pub use state::{
+    DeletedMessages, EditedMessage, FakeTdClient, ForwardedMessages, PendingViewMessages,
+    SearchQuery, SentMessage, TdUpdate, ViewedMessages,
+};

crates/tele-core/src/test_support/fake_tdclient/builders.rs

@@ -0,0 +1,86 @@
+use super::{FakeTdClient, TdUpdate};
+use crate::tdlib::types::FolderInfo;
+use crate::tdlib::{AuthState, ChatInfo, MessageInfo, NetworkState, ProfileInfo};
+use tokio::sync::mpsc;
+
+#[allow(dead_code)]
+impl FakeTdClient {
+    /// Create an update channel for receiving simulated TDLib events.
+    pub fn with_update_channel(self) -> (Self, mpsc::UnboundedReceiver<TdUpdate>) {
+        let (tx, rx) = mpsc::unbounded_channel();
+        *self.update_tx.lock().unwrap() = Some(tx);
+        (self, rx)
+    }
+
+    /// Enable simulated delays, closer to real TDLib behavior.
+    pub fn with_delays(mut self) -> Self {
+        self.simulate_delays = true;
+        self
+    }
+
+    pub fn with_chat(self, chat: ChatInfo) -> Self {
+        self.chats.lock().unwrap().push(chat);
+        self
+    }
+
+    pub fn with_chats(self, chats: Vec<ChatInfo>) -> Self {
+        self.chats.lock().unwrap().extend(chats);
+        self
+    }
+
+    pub fn with_message(self, chat_id: i64, message: MessageInfo) -> Self {
+        self.messages
+            .lock()
+            .unwrap()
+            .entry(chat_id)
+            .or_default()
+            .push(message);
+        self
+    }
+
+    pub fn with_messages(self, chat_id: i64, messages: Vec<MessageInfo>) -> Self {
+        self.messages.lock().unwrap().insert(chat_id, messages);
+        self
+    }
+
+    pub fn with_folder(self, id: i32, name: &str) -> Self {
+        self.folders
+            .lock()
+            .unwrap()
+            .push(FolderInfo { id, name: name.to_string() });
+        self
+    }
+
+    pub fn with_user(self, id: i64, name: &str) -> Self {
+        self.user_names.lock().unwrap().insert(id, name.to_string());
+        self
+    }
+
+    pub fn with_profile(self, chat_id: i64, profile: ProfileInfo) -> Self {
+        self.profiles.lock().unwrap().insert(chat_id, profile);
+        self
+    }
+
+    pub fn with_network_state(self, state: NetworkState) -> Self {
+        *self.network_state.lock().unwrap() = state;
+        self
+    }
+
+    pub fn with_auth_state(self, state: AuthState) -> Self {
+        *self.auth_state.lock().unwrap() = state;
+        self
+    }
+
+    pub fn with_downloaded_file(self, file_id: i32, path: &str) -> Self {
+        self.downloaded_files
+            .lock()
+            .unwrap()
+            .insert(file_id, path.to_string());
+        self
+    }
+
+    pub fn with_available_reactions(self, reactions: Vec<String>) -> Self {
+        *self.available_reactions.lock().unwrap() = reactions;
+        self
+    }
+}

crates/tele-core/src/test_support/fake_tdclient/inspect.rs

@@ -0,0 +1,92 @@
+use super::{
+    DeletedMessages, EditedMessage, FakeTdClient, ForwardedMessages, SearchQuery, SentMessage,
+    TdUpdate,
+};
+use crate::tdlib::types::FolderInfo;
+use crate::tdlib::{ChatInfo, MessageInfo, NetworkState};
+use tokio::sync::mpsc;
+
+#[allow(dead_code)]
+impl FakeTdClient {
+    pub fn get_chats(&self) -> Vec<ChatInfo> {
+        self.chats.lock().unwrap().clone()
+    }
+
+    pub fn get_folders(&self) -> Vec<FolderInfo> {
+        self.folders.lock().unwrap().clone()
+    }
+
+    pub fn get_messages(&self, chat_id: i64) -> Vec<MessageInfo> {
+        self.messages
+            .lock()
+            .unwrap()
+            .get(&chat_id)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    pub fn get_sent_messages(&self) -> Vec<SentMessage> {
+        self.sent_messages.lock().unwrap().clone()
+    }
+
+    pub fn get_edited_messages(&self) -> Vec<EditedMessage> {
+        self.edited_messages.lock().unwrap().clone()
+    }
+
+    pub fn get_deleted_messages(&self) -> Vec<DeletedMessages> {
+        self.deleted_messages.lock().unwrap().clone()
+    }
+
+    pub fn get_forwarded_messages(&self) -> Vec<ForwardedMessages> {
+        self.forwarded_messages.lock().unwrap().clone()
+    }
+
+    pub fn get_search_queries(&self) -> Vec<SearchQuery> {
+        self.searched_queries.lock().unwrap().clone()
+    }
+
+    pub fn get_viewed_messages(&self) -> Vec<(i64, Vec<i64>)> {
+        self.viewed_messages.lock().unwrap().clone()
+    }
+
+    pub fn get_chat_actions(&self) -> Vec<(i64, String)> {
+        self.chat_actions.lock().unwrap().clone()
+    }
+
+    pub fn get_network_state(&self) -> NetworkState {
+        self.network_state.lock().unwrap().clone()
+    }
+
+    pub fn get_current_chat_id(&self) -> Option<i64> {
+        *self.current_chat_id.lock().unwrap()
+    }
+
+    pub fn set_current_pinned_message(&mut self, msg: Option<MessageInfo>) {
+        *self.current_pinned_message.lock().unwrap() = msg;
+    }
+
+    pub async fn process_pending_view_messages(&mut self) {
+        let mut pending = self.pending_view_messages.lock().unwrap();
+        for (chat_id, message_ids) in pending.drain(..) {
+            let ids: Vec<i64> = message_ids.iter().map(|id| id.as_i64()).collect();
+            self.viewed_messages
+                .lock()
+                .unwrap()
+                .push((chat_id.as_i64(), ids));
+        }
+    }
+
+    pub fn set_update_channel(&self, tx: mpsc::UnboundedSender<TdUpdate>) {
+        *self.update_tx.lock().unwrap() = Some(tx);
+    }
+
+    pub fn clear_all_history(&self) {
+        self.sent_messages.lock().unwrap().clear();
+        self.edited_messages.lock().unwrap().clear();
+        self.deleted_messages.lock().unwrap().clear();
+        self.forwarded_messages.lock().unwrap().clear();
+        self.searched_queries.lock().unwrap().clear();
+        self.viewed_messages.lock().unwrap().clear();
+        self.chat_actions.lock().unwrap().clear();
+    }
+}

crates/tele-core/src/test_support/fake_tdclient/operations.rs

@@ -0,0 +1,458 @@
+use super::{
+    DeletedMessages, EditedMessage, FakeTdClient, ForwardedMessages, SearchQuery, SentMessage,
+    TdUpdate,
+};
+use crate::tdlib::types::ReactionInfo;
+use crate::tdlib::{ChatInfo, MessageInfo, ProfileInfo, ReplyInfo};
+use crate::types::{ChatId, MessageId, UserId};
+
+#[allow(dead_code)]
+impl FakeTdClient {
+    pub async fn load_chats(&self, limit: usize) -> Result<Vec<ChatInfo>, String> {
+        if self.should_fail() {
+            return Err("Failed to load chats".to_string());
+        }
+
+        if self.simulate_delays {
+            tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+        }
+
+        let chats = self
+            .chats
+            .lock()
+            .unwrap()
+            .iter()
+            .take(limit)
+            .cloned()
+            .collect();
+        Ok(chats)
+    }
+
+    pub async fn open_chat(&self, chat_id: ChatId) -> Result<(), String> {
+        if self.should_fail() {
+            return Err("Failed to open chat".to_string());
+        }
+
+        *self.current_chat_id.lock().unwrap() = Some(chat_id.as_i64());
+        Ok(())
+    }
+
+    pub async fn get_chat_history(
+        &self,
+        chat_id: ChatId,
+        limit: i32,
+    ) -> Result<Vec<MessageInfo>, String> {
+        if self.should_fail() {
+            return Err("Failed to load history".to_string());
+        }
+
+        if self.simulate_delays {
+            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        }
+
+        let messages = self
+            .messages
+            .lock()
+            .unwrap()
+            .get(&chat_id.as_i64())
+            .map(|msgs| msgs.iter().take(limit as usize).cloned().collect())
+            .unwrap_or_default();
+
+        Ok(messages)
+    }
+
+    pub async fn load_older_messages(
+        &self,
+        chat_id: ChatId,
+        from_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        if self.should_fail() {
+            return Err("Failed to load older messages".to_string());
+        }
+
+        let messages = self.messages.lock().unwrap();
+        let chat_messages = messages.get(&chat_id.as_i64()).ok_or("Chat not found")?;
+
+        if let Some(idx) = chat_messages.iter().position(|m| m.id() == from_message_id) {
+            let older = chat_messages.iter().take(idx).cloned().collect();
+            Ok(older)
+        } else {
+            Ok(vec![])
+        }
+    }
+
+    pub async fn send_message(
+        &self,
+        chat_id: ChatId,
+        text: String,
+        reply_to: Option<MessageId>,
+        reply_info: Option<ReplyInfo>,
+    ) -> Result<MessageInfo, String> {
+        if self.should_fail() {
+            return Err("Failed to send message".to_string());
+        }
+
+        if self.simulate_delays {
+            tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        }
+
+        let message_id = MessageId::new((self.sent_messages.lock().unwrap().len() as i64) + 1000);
+
+        self.sent_messages.lock().unwrap().push(SentMessage {
+            chat_id: chat_id.as_i64(),
+            text: text.clone(),
+            reply_to,
+            reply_info: reply_info.clone(),
+        });
+
+        let message = MessageInfo::new(
+            message_id,
+            "You".to_string(),
+            true,
+            text,
+            vec![],
+            chrono::Utc::now().timestamp() as i32,
+            0,
+            false,
+            true,
+            true,
+            true,
+            reply_info,
+            None,
+            vec![],
+        );
+
+        self.messages
+            .lock()
+            .unwrap()
+            .entry(chat_id.as_i64())
+            .or_default()
+            .push(message.clone());
+
+        self.send_update(TdUpdate::NewMessage { chat_id, message: Box::new(message.clone()) });
+
+        Ok(message)
+    }
+
+    pub async fn edit_message(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        new_text: String,
+    ) -> Result<MessageInfo, String> {
+        if self.should_fail() {
+            return Err("Failed to edit message".to_string());
+        }
+
+        if self.simulate_delays {
+            tokio::time::sleep(tokio::time::Duration::from_millis(150)).await;
+        }
+
+        self.edited_messages.lock().unwrap().push(EditedMessage {
+            chat_id: chat_id.as_i64(),
+            message_id,
+            new_text: new_text.clone(),
+        });
+
+        let mut messages = self.messages.lock().unwrap();
+        if let Some(chat_msgs) = messages.get_mut(&chat_id.as_i64()) {
+            if let Some(msg) = chat_msgs.iter_mut().find(|m| m.id() == message_id) {
+                msg.content.text = new_text.clone();
+                msg.metadata.edit_date = msg.metadata.date + 60;
+
+                let updated = msg.clone();
+                drop(messages);
+
+                self.send_update(TdUpdate::MessageContent { chat_id, message_id, new_text });
+
+                return Ok(updated);
+            }
+        }
+
+        Err("Message not found".to_string())
+    }
+
+    pub async fn delete_messages(
+        &self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String> {
+        if self.should_fail() {
+            return Err("Failed to delete messages".to_string());
+        }
+
+        if self.simulate_delays {
+            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        }
+
+        self.deleted_messages.lock().unwrap().push(DeletedMessages {
+            chat_id: chat_id.as_i64(),
+            message_ids: message_ids.clone(),
+            revoke,
+        });
+
+        let mut messages = self.messages.lock().unwrap();
+        if let Some(chat_msgs) = messages.get_mut(&chat_id.as_i64()) {
+            chat_msgs.retain(|m| !message_ids.contains(&m.id()));
+        }
+        drop(messages);
+
+        self.send_update(TdUpdate::DeleteMessages { chat_id, message_ids });
+
+        Ok(())
+    }
+
+    pub async fn forward_messages(
+        &self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String> {
+        if self.should_fail() {
+            return Err("Failed to forward messages".to_string());
+        }
+
+        if self.simulate_delays {
+            tokio::time::sleep(tokio::time::Duration::from_millis(150)).await;
+        }
+
+        self.forwarded_messages
+            .lock()
+            .unwrap()
+            .push(ForwardedMessages {
+                from_chat_id: from_chat_id.as_i64(),
+                to_chat_id: to_chat_id.as_i64(),
+                message_ids,
+            });
+
+        Ok(())
+    }
+
+    pub async fn search_messages(
+        &self,
+        chat_id: ChatId,
+        query: &str,
+    ) -> Result<Vec<MessageInfo>, String> {
+        if self.should_fail() {
+            return Err("Failed to search messages".to_string());
+        }
+
+        let messages = self.messages.lock().unwrap();
+        let results: Vec<_> = messages
+            .get(&chat_id.as_i64())
+            .map(|msgs| {
+                msgs.iter()
+                    .filter(|m| m.text().to_lowercase().contains(&query.to_lowercase()))
+                    .cloned()
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        self.searched_queries.lock().unwrap().push(SearchQuery {
+            chat_id: chat_id.as_i64(),
+            query: query.to_string(),
+            results_count: results.len(),
+        });
+
+        Ok(results)
+    }
+
+    pub async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String> {
+        if text.is_empty() {
+            self.drafts.lock().unwrap().remove(&chat_id.as_i64());
+        } else {
+            self.drafts
+                .lock()
+                .unwrap()
+                .insert(chat_id.as_i64(), text.clone());
+        }
+
+        self.send_update(TdUpdate::ChatDraftMessage {
+            chat_id,
+            draft_text: if text.is_empty() { None } else { Some(text) },
+        });
+
+        Ok(())
+    }
+
+    pub async fn send_chat_action(&self, chat_id: ChatId, action: String) {
+        self.chat_actions
+            .lock()
+            .unwrap()
+            .push((chat_id.as_i64(), action.clone()));
+
+        if action == "Typing" {
+            *self.typing_chat_id.lock().unwrap() = Some(chat_id.as_i64());
+        } else if action == "Cancel" {
+            *self.typing_chat_id.lock().unwrap() = None;
+        }
+    }
+
+    pub async fn get_message_available_reactions(
+        &self,
+        _chat_id: ChatId,
+        _message_id: MessageId,
+    ) -> Result<Vec<String>, String> {
+        if self.should_fail() {
+            return Err("Failed to get available reactions".to_string());
+        }
+
+        Ok(self.available_reactions.lock().unwrap().clone())
+    }
+
+    pub async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        emoji: String,
+    ) -> Result<(), String> {
+        if self.should_fail() {
+            return Err("Failed to toggle reaction".to_string());
+        }
+
+        let mut messages = self.messages.lock().unwrap();
+        if let Some(chat_msgs) = messages.get_mut(&chat_id.as_i64()) {
+            if let Some(msg) = chat_msgs.iter_mut().find(|m| m.id() == message_id) {
+                let reactions = &mut msg.interactions.reactions;
+
+                if let Some(pos) = reactions
+                    .iter()
+                    .position(|reaction| reaction.emoji == emoji && reaction.is_chosen)
+                {
+                    reactions.remove(pos);
+                } else if let Some(reaction) = reactions
+                    .iter_mut()
+                    .find(|reaction| reaction.emoji == emoji)
+                {
+                    reaction.is_chosen = true;
+                    reaction.count += 1;
+                } else {
+                    reactions.push(ReactionInfo {
+                        emoji: emoji.clone(),
+                        count: 1,
+                        is_chosen: true,
+                    });
+                }
+
+                let updated_reactions = reactions.clone();
+                drop(messages);
+
+                self.send_update(TdUpdate::MessageInteractionInfo {
+                    chat_id,
+                    message_id,
+                    reactions: updated_reactions,
+                });
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn download_file(&self, file_id: i32) -> Result<String, String> {
+        if self.should_fail() {
+            return Err("Failed to download file".to_string());
+        }
+
+        self.downloaded_files
+            .lock()
+            .unwrap()
+            .get(&file_id)
+            .cloned()
+            .ok_or_else(|| format!("File {} not found", file_id))
+    }
+
+    pub async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String> {
+        if self.should_fail() {
+            return Err("Failed to get profile info".to_string());
+        }
+
+        self.profiles
+            .lock()
+            .unwrap()
+            .get(&chat_id.as_i64())
+            .cloned()
+            .ok_or_else(|| "Profile not found".to_string())
+    }
+
+    pub async fn view_messages(&self, chat_id: ChatId, message_ids: Vec<MessageId>) {
+        self.viewed_messages
+            .lock()
+            .unwrap()
+            .push((chat_id.as_i64(), message_ids.iter().map(|id| id.as_i64()).collect()));
+    }
+
+    pub async fn load_folder_chats(&self, _folder_id: i32, _limit: usize) -> Result<(), String> {
+        if self.should_fail() {
+            return Err("Failed to load folder chats".to_string());
+        }
+
+        Ok(())
+    }
+
+    fn send_update(&self, update: TdUpdate) {
+        if let Some(tx) = self.update_tx.lock().unwrap().as_ref() {
+            let _ = tx.send(update);
+        }
+    }
+
+    fn should_fail(&self) -> bool {
+        let mut fail = self.fail_next_operation.lock().unwrap();
+        if *fail {
+            *fail = false;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn fail_next(&self) {
+        *self.fail_next_operation.lock().unwrap() = true;
+    }
+
+    pub fn simulate_incoming_message(&self, chat_id: ChatId, text: String, sender_name: &str) {
+        let message_id = MessageId::new(9000 + chrono::Utc::now().timestamp());
+
+        let message = MessageInfo::new(
+            message_id,
+            sender_name.to_string(),
+            false,
+            text,
+            vec![],
+            chrono::Utc::now().timestamp() as i32,
+            0,
+            false,
+            false,
+            false,
+            true,
+            None,
+            None,
+            vec![],
+        );
+
+        self.messages
+            .lock()
+            .unwrap()
+            .entry(chat_id.as_i64())
+            .or_default()
+            .push(message.clone());
+
+        self.send_update(TdUpdate::NewMessage { chat_id, message: Box::new(message) });
+    }
+
+    pub fn simulate_typing(&self, chat_id: ChatId, user_id: UserId) {
+        self.send_update(TdUpdate::ChatAction { chat_id, user_id, action: "Typing".to_string() });
+    }
+
+    pub fn simulate_network_change(&self, state: crate::tdlib::NetworkState) {
+        *self.network_state.lock().unwrap() = state.clone();
+        self.send_update(TdUpdate::ConnectionState { state });
+    }
+
+    pub fn simulate_read_outbox(&self, chat_id: ChatId, last_read_message_id: MessageId) {
+        self.send_update(TdUpdate::ChatReadOutbox {
+            chat_id,
+            last_read_outbox_message_id: last_read_message_id,
+        });
+    }
+}

crates/tele-core/src/test_support/fake_tdclient/state.rs

@@ -0,0 +1,201 @@
+use crate::tdlib::types::{FolderInfo, ReactionInfo};
+use crate::tdlib::{AuthState, ChatInfo, MessageInfo, NetworkState, ProfileInfo, ReplyInfo};
+use crate::types::{ChatId, MessageId, UserId};
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use tokio::sync::mpsc;
+
+pub type ViewedMessages = Vec<(i64, Vec<i64>)>;
+pub type PendingViewMessages = Vec<(ChatId, Vec<MessageId>)>;
+
+/// Update events from TDLib, simplified for tests.
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum TdUpdate {
+    NewMessage {
+        chat_id: ChatId,
+        message: Box<MessageInfo>,
+    },
+    MessageContent {
+        chat_id: ChatId,
+        message_id: MessageId,
+        new_text: String,
+    },
+    DeleteMessages {
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    },
+    ChatAction {
+        chat_id: ChatId,
+        user_id: UserId,
+        action: String,
+    },
+    MessageInteractionInfo {
+        chat_id: ChatId,
+        message_id: MessageId,
+        reactions: Vec<ReactionInfo>,
+    },
+    ConnectionState {
+        state: NetworkState,
+    },
+    ChatReadOutbox {
+        chat_id: ChatId,
+        last_read_outbox_message_id: MessageId,
+    },
+    ChatDraftMessage {
+        chat_id: ChatId,
+        draft_text: Option<String>,
+    },
+}
+
+/// Simplified mock TDLib client for tests.
+#[allow(dead_code)]
+pub struct FakeTdClient {
+    pub chats: Arc<Mutex<Vec<ChatInfo>>>,
+    pub messages: Arc<Mutex<HashMap<i64, Vec<MessageInfo>>>>,
+    pub folders: Arc<Mutex<Vec<FolderInfo>>>,
+    pub user_names: Arc<Mutex<HashMap<i64, String>>>,
+    pub profiles: Arc<Mutex<HashMap<i64, ProfileInfo>>>,
+    pub drafts: Arc<Mutex<HashMap<i64, String>>>,
+    pub available_reactions: Arc<Mutex<Vec<String>>>,
+
+    pub network_state: Arc<Mutex<NetworkState>>,
+    pub typing_chat_id: Arc<Mutex<Option<i64>>>,
+    pub current_chat_id: Arc<Mutex<Option<i64>>>,
+    pub current_pinned_message: Arc<Mutex<Option<MessageInfo>>>,
+    pub auth_state: Arc<Mutex<AuthState>>,
+
+    pub sent_messages: Arc<Mutex<Vec<SentMessage>>>,
+    pub edited_messages: Arc<Mutex<Vec<EditedMessage>>>,
+    pub deleted_messages: Arc<Mutex<Vec<DeletedMessages>>>,
+    pub forwarded_messages: Arc<Mutex<Vec<ForwardedMessages>>>,
+    pub searched_queries: Arc<Mutex<Vec<SearchQuery>>>,
+    pub viewed_messages: Arc<Mutex<ViewedMessages>>,
+    pub chat_actions: Arc<Mutex<Vec<(i64, String)>>>,
+    pub pending_view_messages: Arc<Mutex<PendingViewMessages>>,
+
+    pub update_tx: Arc<Mutex<Option<mpsc::UnboundedSender<TdUpdate>>>>,
+    pub downloaded_files: Arc<Mutex<HashMap<i32, String>>>,
+
+    pub simulate_delays: bool,
+    pub fail_next_operation: Arc<Mutex<bool>>,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct SentMessage {
+    pub chat_id: i64,
+    pub text: String,
+    pub reply_to: Option<MessageId>,
+    pub reply_info: Option<ReplyInfo>,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct EditedMessage {
+    pub chat_id: i64,
+    pub message_id: MessageId,
+    pub new_text: String,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct DeletedMessages {
+    pub chat_id: i64,
+    pub message_ids: Vec<MessageId>,
+    pub revoke: bool,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct ForwardedMessages {
+    pub from_chat_id: i64,
+    pub to_chat_id: i64,
+    pub message_ids: Vec<MessageId>,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct SearchQuery {
+    pub chat_id: i64,
+    pub query: String,
+    pub results_count: usize,
+}
+
+impl Default for FakeTdClient {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Clone for FakeTdClient {
+    fn clone(&self) -> Self {
+        Self {
+            chats: Arc::clone(&self.chats),
+            messages: Arc::clone(&self.messages),
+            folders: Arc::clone(&self.folders),
+            user_names: Arc::clone(&self.user_names),
+            profiles: Arc::clone(&self.profiles),
+            drafts: Arc::clone(&self.drafts),
+            available_reactions: Arc::clone(&self.available_reactions),
+            network_state: Arc::clone(&self.network_state),
+            typing_chat_id: Arc::clone(&self.typing_chat_id),
+            current_chat_id: Arc::clone(&self.current_chat_id),
+            current_pinned_message: Arc::clone(&self.current_pinned_message),
+            auth_state: Arc::clone(&self.auth_state),
+            sent_messages: Arc::clone(&self.sent_messages),
+            edited_messages: Arc::clone(&self.edited_messages),
+            deleted_messages: Arc::clone(&self.deleted_messages),
+            forwarded_messages: Arc::clone(&self.forwarded_messages),
+            searched_queries: Arc::clone(&self.searched_queries),
+            viewed_messages: Arc::clone(&self.viewed_messages),
+            chat_actions: Arc::clone(&self.chat_actions),
+            pending_view_messages: Arc::clone(&self.pending_view_messages),
+            downloaded_files: Arc::clone(&self.downloaded_files),
+            update_tx: Arc::clone(&self.update_tx),
+            simulate_delays: self.simulate_delays,
+            fail_next_operation: Arc::clone(&self.fail_next_operation),
+        }
+    }
+}
+
+#[allow(dead_code)]
+impl FakeTdClient {
+    pub fn new() -> Self {
+        Self {
+            chats: Arc::new(Mutex::new(vec![])),
+            messages: Arc::new(Mutex::new(HashMap::new())),
+            folders: Arc::new(Mutex::new(vec![FolderInfo { id: 0, name: "All".to_string() }])),
+            user_names: Arc::new(Mutex::new(HashMap::new())),
+            profiles: Arc::new(Mutex::new(HashMap::new())),
+            drafts: Arc::new(Mutex::new(HashMap::new())),
+            available_reactions: Arc::new(Mutex::new(vec![
+                "👍".to_string(),
+                "❤️".to_string(),
+                "😂".to_string(),
+                "😮".to_string(),
+                "😢".to_string(),
+                "🙏".to_string(),
+                "👏".to_string(),
+                "🔥".to_string(),
+            ])),
+            network_state: Arc::new(Mutex::new(NetworkState::Ready)),
+            typing_chat_id: Arc::new(Mutex::new(None)),
+            current_chat_id: Arc::new(Mutex::new(None)),
+            current_pinned_message: Arc::new(Mutex::new(None)),
+            auth_state: Arc::new(Mutex::new(AuthState::Ready)),
+            sent_messages: Arc::new(Mutex::new(vec![])),
+            edited_messages: Arc::new(Mutex::new(vec![])),
+            deleted_messages: Arc::new(Mutex::new(vec![])),
+            forwarded_messages: Arc::new(Mutex::new(vec![])),
+            searched_queries: Arc::new(Mutex::new(vec![])),
+            viewed_messages: Arc::new(Mutex::new(vec![])),
+            chat_actions: Arc::new(Mutex::new(vec![])),
+            pending_view_messages: Arc::new(Mutex::new(vec![])),
+            downloaded_files: Arc::new(Mutex::new(HashMap::new())),
+            update_tx: Arc::new(Mutex::new(None)),
+            simulate_delays: false,
+            fail_next_operation: Arc::new(Mutex::new(false)),
+        }
+    }
+}

crates/tele-core/src/test_support/fake_tdclient_impl.rs

@@ -0,0 +1,358 @@
+//! Test implementation of the TDLib client traits for FakeTdClient.
+
+use super::fake_tdclient::FakeTdClient;
+use crate::tdlib::{
+    AccountClient, AuthClient, ChatActionClient, ChatClient, ClientState, FileClient,
+    MessageClient, ReactionClient, UpdateClient, UserClient,
+};
+use crate::tdlib::{
+    AuthState, ChatInfo, FolderInfo, MessageInfo, ProfileInfo, ReplyInfo, UserCache,
+    UserOnlineStatus,
+};
+use crate::types::{ChatId, MessageId, UserId};
+use async_trait::async_trait;
+use std::borrow::Cow;
+use std::path::PathBuf;
+use tdlib_rs::enums::{ChatAction, Update};
+
+#[async_trait]
+impl AuthClient for FakeTdClient {
+    async fn send_phone_number(&self, _phone: String) -> Result<(), String> {
+        Ok(())
+    }
+
+    async fn send_code(&self, _code: String) -> Result<(), String> {
+        Ok(())
+    }
+
+    async fn send_password(&self, _password: String) -> Result<(), String> {
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl ChatClient for FakeTdClient {
+    async fn load_chats(&mut self, limit: i32) -> Result<(), String> {
+        let _ = FakeTdClient::load_chats(self, limit as usize).await?;
+        Ok(())
+    }
+
+    async fn load_folder_chats(&mut self, folder_id: i32, limit: i32) -> Result<(), String> {
+        FakeTdClient::load_folder_chats(self, folder_id, limit as usize).await
+    }
+
+    async fn leave_chat(&self, _chat_id: ChatId) -> Result<(), String> {
+        Ok(())
+    }
+
+    async fn get_profile_info(&self, chat_id: ChatId) -> Result<ProfileInfo, String> {
+        FakeTdClient::get_profile_info(self, chat_id).await
+    }
+
+    fn chats(&self) -> &[ChatInfo] {
+        &[]
+    }
+
+    fn folders(&self) -> &[FolderInfo] {
+        &[]
+    }
+
+    fn main_chat_list_position(&self) -> i32 {
+        0
+    }
+
+    fn set_main_chat_list_position(&mut self, _position: i32) {}
+
+    fn update_chats<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<ChatInfo>),
+    {
+        updater(&mut self.chats.lock().unwrap());
+    }
+
+    fn update_folders<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<FolderInfo>),
+    {
+        updater(&mut self.folders.lock().unwrap());
+    }
+}
+
+#[async_trait]
+impl ChatActionClient for FakeTdClient {
+    async fn send_chat_action(&self, chat_id: ChatId, action: ChatAction) {
+        FakeTdClient::send_chat_action(self, chat_id, format!("{:?}", action)).await;
+    }
+
+    fn clear_stale_typing_status(&mut self) -> bool {
+        false
+    }
+
+    fn typing_status(&self) -> Option<&(UserId, String, std::time::Instant)> {
+        None
+    }
+
+    fn set_typing_status(&mut self, _status: Option<(UserId, String, std::time::Instant)>) {}
+}
+
+#[async_trait]
+impl MessageClient for FakeTdClient {
+    async fn get_chat_history(
+        &mut self,
+        chat_id: ChatId,
+        limit: i32,
+    ) -> Result<Vec<MessageInfo>, String> {
+        FakeTdClient::get_chat_history(self, chat_id, limit).await
+    }
+
+    async fn load_older_messages(
+        &mut self,
+        chat_id: ChatId,
+        from_message_id: MessageId,
+    ) -> Result<Vec<MessageInfo>, String> {
+        FakeTdClient::load_older_messages(self, chat_id, from_message_id).await
+    }
+
+    async fn get_pinned_messages(&mut self, _chat_id: ChatId) -> Result<Vec<MessageInfo>, String> {
+        Ok(vec![])
+    }
+
+    async fn load_current_pinned_message(&mut self, _chat_id: ChatId) {}
+
+    async fn search_messages(
+        &self,
+        chat_id: ChatId,
+        query: &str,
+    ) -> Result<Vec<MessageInfo>, String> {
+        FakeTdClient::search_messages(self, chat_id, query).await
+    }
+
+    async fn send_message(
+        &mut self,
+        chat_id: ChatId,
+        text: String,
+        reply_to_message_id: Option<MessageId>,
+        reply_info: Option<ReplyInfo>,
+    ) -> Result<MessageInfo, String> {
+        FakeTdClient::send_message(self, chat_id, text, reply_to_message_id, reply_info).await
+    }
+
+    async fn edit_message(
+        &mut self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        new_text: String,
+    ) -> Result<MessageInfo, String> {
+        FakeTdClient::edit_message(self, chat_id, message_id, new_text).await
+    }
+
+    async fn delete_messages(
+        &mut self,
+        chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+        revoke: bool,
+    ) -> Result<(), String> {
+        FakeTdClient::delete_messages(self, chat_id, message_ids, revoke).await
+    }
+
+    async fn forward_messages(
+        &mut self,
+        to_chat_id: ChatId,
+        from_chat_id: ChatId,
+        message_ids: Vec<MessageId>,
+    ) -> Result<(), String> {
+        FakeTdClient::forward_messages(self, from_chat_id, to_chat_id, message_ids).await
+    }
+
+    async fn set_draft_message(&self, chat_id: ChatId, text: String) -> Result<(), String> {
+        FakeTdClient::set_draft_message(self, chat_id, text).await
+    }
+
+    fn current_chat_messages(&self) -> Cow<'_, [MessageInfo]> {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            Cow::Owned(self.get_messages(chat_id))
+        } else {
+            Cow::Owned(Vec::new())
+        }
+    }
+
+    fn current_chat_id(&self) -> Option<ChatId> {
+        self.get_current_chat_id().map(ChatId::new)
+    }
+
+    fn current_pinned_message(&self) -> Option<MessageInfo> {
+        self.current_pinned_message.lock().unwrap().clone()
+    }
+
+    fn push_message(&mut self, msg: MessageInfo) {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            self.messages
+                .lock()
+                .unwrap()
+                .entry(chat_id)
+                .or_default()
+                .push(msg);
+        }
+    }
+
+    fn clear_current_chat_messages(&mut self) {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            self.messages.lock().unwrap().remove(&chat_id);
+        }
+    }
+
+    fn set_current_chat_messages(&mut self, messages: Vec<MessageInfo>) {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            self.messages.lock().unwrap().insert(chat_id, messages);
+        }
+    }
+
+    fn update_current_chat_messages<F>(&mut self, updater: F)
+    where
+        F: FnOnce(&mut Vec<MessageInfo>),
+    {
+        if let Some(chat_id) = *self.current_chat_id.lock().unwrap() {
+            let mut all_messages = self.messages.lock().unwrap();
+            updater(all_messages.entry(chat_id).or_default());
+        }
+    }
+
+    fn set_current_chat_id(&mut self, chat_id: Option<ChatId>) {
+        *self.current_chat_id.lock().unwrap() = chat_id.map(|id| id.as_i64());
+    }
+
+    fn set_current_pinned_message(&mut self, msg: Option<MessageInfo>) {
+        *self.current_pinned_message.lock().unwrap() = msg;
+    }
+
+    fn pending_view_messages(&self) -> &[(ChatId, Vec<MessageId>)] {
+        &[]
+    }
+
+    fn enqueue_pending_view_messages(&mut self, chat_id: ChatId, message_ids: Vec<MessageId>) {
+        self.pending_view_messages
+            .lock()
+            .unwrap()
+            .push((chat_id, message_ids));
+    }
+
+    async fn fetch_missing_reply_info(&mut self) {}
+
+    async fn process_pending_view_messages(&mut self) {
+        let mut pending = self.pending_view_messages.lock().unwrap();
+        for (chat_id, message_ids) in pending.drain(..) {
+            let ids: Vec<i64> = message_ids.iter().map(|id| id.as_i64()).collect();
+            self.viewed_messages
+                .lock()
+                .unwrap()
+                .push((chat_id.as_i64(), ids));
+        }
+    }
+}
+
+#[async_trait]
+impl UserClient for FakeTdClient {
+    fn get_user_status_by_chat_id(&self, _chat_id: ChatId) -> Option<&UserOnlineStatus> {
+        None
+    }
+
+    fn pending_user_ids(&self) -> &[UserId] {
+        &[]
+    }
+
+    fn user_cache(&self) -> &UserCache {
+        use std::sync::OnceLock;
+        static EMPTY_CACHE: OnceLock<UserCache> = OnceLock::new();
+        EMPTY_CACHE.get_or_init(|| UserCache::new(0))
+    }
+
+    fn update_user_cache<F>(&mut self, _updater: F)
+    where
+        F: FnOnce(&mut UserCache),
+    {
+    }
+
+    async fn process_pending_user_ids(&mut self) {}
+}
+
+#[async_trait]
+impl ReactionClient for FakeTdClient {
+    async fn get_message_available_reactions(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+    ) -> Result<Vec<String>, String> {
+        FakeTdClient::get_message_available_reactions(self, chat_id, message_id).await
+    }
+
+    async fn toggle_reaction(
+        &self,
+        chat_id: ChatId,
+        message_id: MessageId,
+        reaction: String,
+    ) -> Result<(), String> {
+        FakeTdClient::toggle_reaction(self, chat_id, message_id, reaction).await
+    }
+}
+
+#[async_trait]
+impl FileClient for FakeTdClient {
+    async fn download_file(&self, file_id: i32) -> Result<String, String> {
+        FakeTdClient::download_file(self, file_id).await
+    }
+
+    async fn download_voice_note(&self, file_id: i32) -> Result<String, String> {
+        Ok(format!("/tmp/fake_voice_{}.ogg", file_id))
+    }
+}
+
+#[async_trait]
+impl ClientState for FakeTdClient {
+    fn client_id(&self) -> i32 {
+        0
+    }
+
+    async fn get_me(&self) -> Result<i64, String> {
+        Ok(12345)
+    }
+
+    fn auth_state(&self) -> &AuthState {
+        use std::sync::OnceLock;
+        static AUTH_STATE_READY: AuthState = AuthState::Ready;
+        static AUTH_STATE_WAIT_PHONE: OnceLock<AuthState> = OnceLock::new();
+        static AUTH_STATE_WAIT_CODE: OnceLock<AuthState> = OnceLock::new();
+        static AUTH_STATE_WAIT_PASSWORD: OnceLock<AuthState> = OnceLock::new();
+
+        let current = self.auth_state.lock().unwrap();
+        match *current {
+            AuthState::Ready => &AUTH_STATE_READY,
+            AuthState::WaitPhoneNumber => {
+                AUTH_STATE_WAIT_PHONE.get_or_init(|| AuthState::WaitPhoneNumber)
+            }
+            AuthState::WaitCode => AUTH_STATE_WAIT_CODE.get_or_init(|| AuthState::WaitCode),
+            AuthState::WaitPassword => {
+                AUTH_STATE_WAIT_PASSWORD.get_or_init(|| AuthState::WaitPassword)
+            }
+            _ => &AUTH_STATE_READY,
+        }
+    }
+
+    fn network_state(&self) -> crate::tdlib::types::NetworkState {
+        FakeTdClient::get_network_state(self)
+    }
+}
+
+#[async_trait]
+impl AccountClient for FakeTdClient {
+    async fn recreate_client(&mut self, _db_path: PathBuf) -> Result<(), String> {
+        Ok(())
+    }
+}
+
+impl UpdateClient for FakeTdClient {
+    fn handle_update(&mut self, _update: Update) {}
+
+    fn drain_incoming_message_events(&mut self) -> Vec<crate::tdlib::IncomingMessageEvent> {
+        Vec::new()
+    }
+}

crates/tele-core/src/test_support/mod.rs

@@ -0,0 +1,7 @@
+//! Core test support for deterministic TDLib fixtures.
+
+pub mod fake_tdclient;
+mod fake_tdclient_impl;
+pub mod test_data;
+
+pub use fake_tdclient::FakeTdClient;

crates/tele-core/src/test_support/test_data.rs

@@ -0,0 +1,252 @@
+// Test data builders and fixtures
+
+use crate::tdlib::types::{ForwardInfo, ReactionInfo};
+use crate::tdlib::{ChatInfo, MessageInfo, ProfileInfo, ReplyInfo};
+use crate::types::{ChatId, MessageId};
+
+/// Builder для создания тестового чата
+#[allow(dead_code)]
+pub struct TestChatBuilder {
+    id: i64,
+    title: String,
+    username: Option<String>,
+    last_message: String,
+    last_message_date: i32,
+    unread_count: i32,
+    unread_mention_count: i32,
+    is_pinned: bool,
+    order: i64,
+    last_read_outbox_message_id: i64,
+    folder_ids: Vec<i32>,
+    is_muted: bool,
+    draft_text: Option<String>,
+}
+
+#[allow(dead_code)]
+impl TestChatBuilder {
+    pub fn new(title: &str, id: i64) -> Self {
+        Self {
+            id,
+            title: title.to_string(),
+            username: None,
+            last_message: "".to_string(),
+            last_message_date: 1640000000,
+            unread_count: 0,
+            unread_mention_count: 0,
+            is_pinned: false,
+            order: id,
+            last_read_outbox_message_id: 0,
+            folder_ids: vec![0],
+            is_muted: false,
+            draft_text: None,
+        }
+    }
+
+    pub fn username(mut self, username: &str) -> Self {
+        self.username = Some(username.to_string());
+        self
+    }
+
+    pub fn last_message(mut self, text: &str) -> Self {
+        self.last_message = text.to_string();
+        self
+    }
+
+    pub fn unread_count(mut self, count: i32) -> Self {
+        self.unread_count = count;
+        self
+    }
+
+    pub fn unread_mentions(mut self, count: i32) -> Self {
+        self.unread_mention_count = count;
+        self
+    }
+
+    pub fn pinned(mut self) -> Self {
+        self.is_pinned = true;
+        self
+    }
+
+    pub fn muted(mut self) -> Self {
+        self.is_muted = true;
+        self
+    }
+
+    pub fn draft(mut self, text: &str) -> Self {
+        self.draft_text = Some(text.to_string());
+        self
+    }
+
+    pub fn folder(mut self, folder_id: i32) -> Self {
+        self.folder_ids = vec![folder_id];
+        self
+    }
+
+    pub fn build(self) -> ChatInfo {
+        ChatInfo {
+            id: ChatId::new(self.id),
+            title: self.title,
+            username: self.username,
+            last_message: self.last_message,
+            last_message_date: self.last_message_date,
+            unread_count: self.unread_count,
+            unread_mention_count: self.unread_mention_count,
+            is_pinned: self.is_pinned,
+            order: self.order,
+            last_read_outbox_message_id: MessageId::new(self.last_read_outbox_message_id),
+            folder_ids: self.folder_ids,
+            is_muted: self.is_muted,
+            draft_text: self.draft_text,
+        }
+    }
+}
+
+/// Builder для создания тестового сообщения
+#[allow(dead_code)]
+pub struct TestMessageBuilder {
+    id: i64,
+    sender_name: String,
+    is_outgoing: bool,
+    content: String,
+    entities: Vec<tdlib_rs::types::TextEntity>,
+    date: i32,
+    edit_date: i32,
+    is_read: bool,
+    can_be_edited: bool,
+    can_be_deleted_only_for_self: bool,
+    can_be_deleted_for_all_users: bool,
+    reply_to: Option<ReplyInfo>,
+    forward_from: Option<ForwardInfo>,
+    reactions: Vec<ReactionInfo>,
+    media_album_id: i64,
+}
+
+#[allow(dead_code)]
+impl TestMessageBuilder {
+    pub fn new(content: &str, id: i64) -> Self {
+        Self {
+            id,
+            sender_name: "User".to_string(),
+            is_outgoing: false,
+            content: content.to_string(),
+            entities: vec![],
+            date: 1640000000,
+            edit_date: 0,
+            is_read: true,
+            can_be_edited: false,
+            can_be_deleted_only_for_self: true,
+            can_be_deleted_for_all_users: false,
+            reply_to: None,
+            forward_from: None,
+            reactions: vec![],
+            media_album_id: 0,
+        }
+    }
+
+    pub fn outgoing(mut self) -> Self {
+        self.is_outgoing = true;
+        self.sender_name = "You".to_string();
+        self.can_be_edited = true;
+        self.can_be_deleted_for_all_users = true;
+        self
+    }
+
+    pub fn sender(mut self, name: &str) -> Self {
+        self.sender_name = name.to_string();
+        self
+    }
+
+    pub fn date(mut self, timestamp: i32) -> Self {
+        self.date = timestamp;
+        self
+    }
+
+    pub fn edited(mut self) -> Self {
+        self.edit_date = self.date + 60;
+        self
+    }
+
+    pub fn unread(mut self) -> Self {
+        self.is_read = false;
+        self
+    }
+
+    pub fn reply_to(mut self, message_id: i64, sender: &str, text: &str) -> Self {
+        self.reply_to = Some(ReplyInfo {
+            message_id: MessageId::new(message_id),
+            sender_name: sender.to_string(),
+            text: text.to_string(),
+        });
+        self
+    }
+
+    pub fn forwarded_from(mut self, sender: &str) -> Self {
+        self.forward_from = Some(ForwardInfo { sender_name: sender.to_string() });
+        self
+    }
+
+    pub fn reaction(mut self, emoji: &str, count: i32, chosen: bool) -> Self {
+        self.reactions
+            .push(ReactionInfo { emoji: emoji.to_string(), count, is_chosen: chosen });
+        self
+    }
+
+    pub fn media_album_id(mut self, id: i64) -> Self {
+        self.media_album_id = id;
+        self
+    }
+
+    pub fn build(self) -> MessageInfo {
+        let mut msg = MessageInfo::new(
+            MessageId::new(self.id),
+            self.sender_name,
+            self.is_outgoing,
+            self.content,
+            self.entities,
+            self.date,
+            self.edit_date,
+            self.is_read,
+            self.can_be_edited,
+            self.can_be_deleted_only_for_self,
+            self.can_be_deleted_for_all_users,
+            self.reply_to,
+            self.forward_from,
+            self.reactions,
+        );
+        msg.metadata.media_album_id = self.media_album_id;
+        msg
+    }
+}
+
+/// Хелперы для быстрого создания тестовых данных
+pub fn create_test_chat(title: &str, id: i64) -> ChatInfo {
+    TestChatBuilder::new(title, id).build()
+}
+
+#[allow(dead_code)]
+pub fn create_test_message(content: &str, id: i64) -> MessageInfo {
+    TestMessageBuilder::new(content, id).build()
+}
+
+#[allow(dead_code)]
+pub fn create_test_user(name: &str, id: i64) -> (i64, String) {
+    (id, name.to_string())
+}
+
+/// Хелпер для создания профиля
+#[allow(dead_code)]
+pub fn create_test_profile(title: &str, chat_id: i64) -> ProfileInfo {
+    ProfileInfo {
+        chat_id: ChatId::new(chat_id),
+        title: title.to_string(),
+        username: None,
+        bio: None,
+        phone_number: None,
+        chat_type: "Личный чат".to_string(),
+        member_count: None,
+        description: None,
+        invite_link: None,
+        is_group: false,
+        online_status: None,
+    }
+}

crates/tele-core/src/types.rs

@@ -0,0 +1,172 @@
+//! Type-safe ID wrappers to prevent mixing up different ID types.
+//!
+//! Provides `ChatId` and `MessageId` newtypes for compile-time safety.
+
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// Chat identifier
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct ChatId(pub i64);
+
+impl ChatId {
+    pub fn new(id: i64) -> Self {
+        Self(id)
+    }
+
+    pub fn as_i64(&self) -> i64 {
+        self.0
+    }
+}
+
+impl From<i64> for ChatId {
+    fn from(id: i64) -> Self {
+        Self(id)
+    }
+}
+
+impl From<ChatId> for i64 {
+    fn from(id: ChatId) -> Self {
+        id.0
+    }
+}
+
+impl fmt::Display for ChatId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Message identifier
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct MessageId(pub i64);
+
+impl MessageId {
+    pub fn new(id: i64) -> Self {
+        Self(id)
+    }
+
+    pub fn as_i64(&self) -> i64 {
+        self.0
+    }
+}
+
+impl From<i64> for MessageId {
+    fn from(id: i64) -> Self {
+        Self(id)
+    }
+}
+
+impl From<MessageId> for i64 {
+    fn from(id: MessageId) -> Self {
+        id.0
+    }
+}
+
+impl fmt::Display for MessageId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// User identifier
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct UserId(pub i64);
+
+impl UserId {
+    pub fn new(id: i64) -> Self {
+        Self(id)
+    }
+
+    pub fn as_i64(&self) -> i64 {
+        self.0
+    }
+}
+
+impl From<i64> for UserId {
+    fn from(id: i64) -> Self {
+        Self(id)
+    }
+}
+
+impl From<UserId> for i64 {
+    fn from(id: UserId) -> Self {
+        id.0
+    }
+}
+
+impl fmt::Display for UserId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_chat_id() {
+        let id = ChatId::new(123);
+        assert_eq!(id.as_i64(), 123);
+        assert_eq!(i64::from(id), 123);
+
+        let id2: ChatId = 456.into();
+        assert_eq!(id2.0, 456);
+    }
+
+    #[test]
+    fn test_message_id() {
+        let id = MessageId::new(789);
+        assert_eq!(id.as_i64(), 789);
+        assert_eq!(i64::from(id), 789);
+    }
+
+    #[test]
+    fn test_user_id() {
+        let id = UserId::new(111);
+        assert_eq!(id.as_i64(), 111);
+        assert_eq!(i64::from(id), 111);
+    }
+
+    #[test]
+    fn test_type_safety() {
+        // Type safety is enforced at compile time
+        // The following would not compile:
+        // let chat_id = ChatId::new(1);
+        // let message_id = MessageId::new(1);
+        // if chat_id == message_id { } // ERROR: mismatched types
+
+        // Runtime values can be the same, but types are different
+        let chat_id = ChatId::new(1);
+        let message_id = MessageId::new(1);
+        assert_eq!(chat_id.as_i64(), 1);
+        assert_eq!(message_id.as_i64(), 1);
+        // But they cannot be compared directly due to type safety
+    }
+
+    #[test]
+    fn test_display() {
+        let chat_id = ChatId::new(123);
+        assert_eq!(format!("{}", chat_id), "123");
+
+        let message_id = MessageId::new(456);
+        assert_eq!(format!("{}", message_id), "456");
+
+        let user_id = UserId::new(789);
+        assert_eq!(format!("{}", user_id), "789");
+    }
+
+    #[test]
+    fn test_hash_map() {
+        use std::collections::HashMap;
+
+        let mut map = HashMap::new();
+        map.insert(ChatId::new(1), "chat1");
+        map.insert(ChatId::new(2), "chat2");
+
+        assert_eq!(map.get(&ChatId::new(1)), Some(&"chat1"));
+        assert_eq!(map.get(&ChatId::new(2)), Some(&"chat2"));
+        assert_eq!(map.get(&ChatId::new(3)), None);
+    }
+}

crates/tele-core/src/utils.rs

@@ -0,0 +1,9 @@
+use chrono::{DateTime, Local, NaiveDate, Utc};
+
+pub fn get_day(timestamp: i32) -> i64 {
+    let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).expect("valid epoch date");
+    let msg_day = DateTime::<Utc>::from_timestamp(timestamp as i64, 0)
+        .map(|dt| dt.with_timezone(&Local).date_naive())
+        .unwrap_or(epoch);
+    msg_day.signed_duration_since(epoch).num_days()
+}