// Integration tests for reply and forward flow

mod helpers;

use helpers::fake_tdclient::FakeTdClient;
use helpers::test_data::TestMessageBuilder;
use tele_tui::tdlib::{ForwardInfo, ReplyInfo};

/// Test: Reply создаёт сообщение с reply_to
#[test]
fn test_reply_creates_message_with_reply_to() {
    let mut client = FakeTdClient::new();

    // Входящее сообщение от собеседника
    let original_msg = TestMessageBuilder::new("Question?", 100)
        .sender("Alice")
        .build();

    client = client.with_message(123, original_msg);

    // Отвечаем на него
    let reply_id = client.send_message(123, "Answer!".to_string(), Some(100));

    // Проверяем что ответ отправлен с reply_to
    assert_eq!(client.sent_messages().len(), 1);
    assert_eq!(client.sent_messages()[0].reply_to, Some(100));

    // Проверяем что в списке 2 сообщения
    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 2);
    assert_eq!(messages[1].id, reply_id);
    assert_eq!(messages[1].content, "Answer!");
}

/// Test: Reply отображает превью оригинального сообщения
#[test]
fn test_reply_shows_original_preview() {
    let mut client = FakeTdClient::new();

    // Создаём сообщение с reply info
    let reply_msg = TestMessageBuilder::new("Reply text", 101)
        .outgoing()
        .reply_to(100, "Alice", "Original")
        .build();

    client = client.with_message(123, reply_msg);

    // Проверяем что reply_to сохранено
    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 1);
    assert!(messages[0].reply_to.is_some());

    let reply = messages[0].reply_to.as_ref().unwrap();
    assert_eq!(reply.message_id, 100);
    assert_eq!(reply.sender_name, "Alice");
    assert_eq!(reply.text, "Original");
}

/// Test: Отмена reply mode (Esc) - сообщение отправляется без reply_to
#[test]
fn test_cancel_reply_sends_without_reply_to() {
    let mut client = FakeTdClient::new();

    // Входящее сообщение
    let original = TestMessageBuilder::new("Question?", 100)
        .sender("Alice")
        .build();

    client = client.with_message(123, original);

    // Пользователь начал reply (r), потом отменил (Esc), затем отправил
    // Это эмулируется отправкой без reply_to
    client.send_message(123, "Regular message".to_string(), None);

    // Проверяем что отправилось без reply_to
    assert_eq!(client.sent_messages()[0].reply_to, None);

    let messages = client.get_messages(123);
    assert_eq!(messages[1].content, "Regular message");
}

/// Test: Forward создаёт сообщение с forward_from
#[test]
fn test_forward_creates_message_with_forward_from() {
    let mut client = FakeTdClient::new();

    // Создаём пересланное сообщение
    let forwarded_msg = TestMessageBuilder::new("Forwarded text", 200)
        .forwarded_from("Bob")
        .build();

    client = client.with_message(456, forwarded_msg);

    // Проверяем что forward_from сохранено
    let messages = client.get_messages(456);
    assert_eq!(messages.len(), 1);
    assert!(messages[0].forward_from.is_some());

    let forward = messages[0].forward_from.as_ref().unwrap();
    assert_eq!(forward.sender_name, "Bob");
    assert!(forward.date > 0); // Дата установлена
}

/// Test: Forward показывает "↪ Переслано от ..."
/// Проверяем что у пересланного сообщения есть forward_from
#[test]
fn test_forward_displays_sender_name() {
    let mut client = FakeTdClient::new();

    let msg = TestMessageBuilder::new("Important info", 300)
        .forwarded_from("Charlie")
        .build();

    client = client.with_message(789, msg);

    let messages = client.get_messages(789);
    let forward = messages[0].forward_from.as_ref().unwrap();

    // В UI это будет отображаться как "↪ Переслано от Charlie"
    assert_eq!(forward.sender_name, "Charlie");
}

/// Test: Forward в другой чат
#[test]
fn test_forward_to_different_chat() {
    let mut client = FakeTdClient::new();

    // Исходное сообщение в чате 123
    let original = TestMessageBuilder::new("Share this", 100)
        .sender("Alice")
        .build();

    client = client.with_message(123, original);

    // Пересылаем в чат 456
    let forwarded = TestMessageBuilder::new("Share this", 101)
        .forwarded_from("Alice")
        .build();

    client = client.with_message(456, forwarded);

    // Проверяем что в первом чате 1 сообщение
    assert_eq!(client.get_messages(123).len(), 1);

    // Проверяем что во втором чате тоже 1 сообщение (пересланное)
    assert_eq!(client.get_messages(456).len(), 1);
    assert!(client.get_messages(456)[0].forward_from.is_some());
}

/// Test: Reply + Forward комбинация (ответ на пересланное сообщение)
#[test]
fn test_reply_to_forwarded_message() {
    let mut client = FakeTdClient::new();

    // Пересланное сообщение
    let forwarded = TestMessageBuilder::new("Forwarded", 100)
        .forwarded_from("Bob")
        .build();

    client = client.with_message(123, forwarded);

    // Отвечаем на пересланное сообщение
    let reply_id = client.send_message(123, "Thanks for sharing!".to_string(), Some(100));

    // Проверяем что reply содержит reply_to
    assert_eq!(client.sent_messages()[0].reply_to, Some(100));

    let messages = client.get_messages(123);
    assert_eq!(messages.len(), 2);
    assert_eq!(messages[1].id, reply_id);
}

/// Test: Forward множества сообщений (batch forward)
#[test]
fn test_forward_multiple_messages() {
    let mut client = FakeTdClient::new();

    // Создаём 3 пересланных сообщения
    let msg1 = TestMessageBuilder::new("Message 1", 100)
        .forwarded_from("Alice")
        .build();

    let msg2 = TestMessageBuilder::new("Message 2", 101)
        .forwarded_from("Alice")
        .build();

    let msg3 = TestMessageBuilder::new("Message 3", 102)
        .forwarded_from("Alice")
        .build();

    client = client
        .with_message(456, msg1)
        .with_message(456, msg2)
        .with_message(456, msg3);

    // Проверяем что все 3 сообщения пересланы
    let messages = client.get_messages(456);
    assert_eq!(messages.len(), 3);
    assert!(messages[0].forward_from.is_some());
    assert!(messages[1].forward_from.is_some());
    assert!(messages[2].forward_from.is_some());
}