// 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,
};

#[cfg(test)]
mod tests {
    use super::*;
    use crate::helpers::test_data::create_test_chat;
    use tele_tui::types::ChatId;

    #[test]
    fn test_fake_client_creation() {
        let client = FakeTdClient::new();
        assert_eq!(client.get_chats().len(), 0);
        assert_eq!(client.folders.lock().unwrap().len(), 1); // Default "All" folder
    }

    #[test]
    fn test_fake_client_with_chat() {
        let chat = create_test_chat("Mom", 123);
        let client = FakeTdClient::new().with_chat(chat);

        let chats = client.get_chats();
        assert_eq!(chats.len(), 1);
        assert_eq!(chats[0].title, "Mom");
    }

    #[tokio::test]
    async fn test_send_message() {
        let client = FakeTdClient::new();
        let chat_id = ChatId::new(123);

        let result = client
            .send_message(chat_id, "Hello".to_string(), None, None)
            .await;
        assert!(result.is_ok());

        let sent = client.get_sent_messages();
        assert_eq!(sent.len(), 1);
        assert_eq!(sent[0].text, "Hello");
        assert_eq!(client.get_messages(123).len(), 1);
    }

    #[tokio::test]
    async fn test_edit_message() {
        let client = FakeTdClient::new();
        let chat_id = ChatId::new(123);

        let msg = client
            .send_message(chat_id, "Hello".to_string(), None, None)
            .await
            .unwrap();
        let msg_id = msg.id();

        let _ = client
            .edit_message(chat_id, msg_id, "Hello World".to_string())
            .await;

        let edited = client.get_edited_messages();
        assert_eq!(edited.len(), 1);
        assert_eq!(client.get_messages(123)[0].text(), "Hello World");
        assert!(client.get_messages(123)[0].metadata.edit_date > 0);
    }

    #[tokio::test]
    async fn test_delete_message() {
        let client = FakeTdClient::new();
        let chat_id = ChatId::new(123);

        let msg = client
            .send_message(chat_id, "Hello".to_string(), None, None)
            .await
            .unwrap();
        let msg_id = msg.id();

        let _ = client.delete_messages(chat_id, vec![msg_id], false).await;

        let deleted = client.get_deleted_messages();
        assert_eq!(deleted.len(), 1);
        assert_eq!(client.get_messages(123).len(), 0);
    }

    #[tokio::test]
    async fn test_update_channel() {
        let (client, mut rx) = FakeTdClient::new().with_update_channel();
        let chat_id = ChatId::new(123);

        let _ = client
            .send_message(chat_id, "Test".to_string(), None, None)
            .await;

        if let Some(update) = rx.recv().await {
            match update {
                TdUpdate::NewMessage { chat_id: updated_chat, .. } => {
                    assert_eq!(updated_chat, chat_id);
                }
                _ => panic!("Expected NewMessage update"),
            }
        } else {
            panic!("No update received");
        }
    }

    #[tokio::test]
    async fn test_simulate_incoming_message() {
        let (client, mut rx) = FakeTdClient::new().with_update_channel();
        let chat_id = ChatId::new(123);

        client.simulate_incoming_message(chat_id, "Hello from Bob".to_string(), "Bob");

        if let Some(TdUpdate::NewMessage { message, .. }) = rx.recv().await {
            assert_eq!(message.text(), "Hello from Bob");
            assert_eq!(message.sender_name(), "Bob");
            assert!(!message.is_outgoing());
        }

        assert_eq!(client.get_messages(123).len(), 1);
    }

    #[tokio::test]
    async fn test_fail_next_operation() {
        let client = FakeTdClient::new();
        let chat_id = ChatId::new(123);

        client.fail_next();

        let result = client
            .send_message(chat_id, "Test".to_string(), None, None)
            .await;
        assert!(result.is_err());

        let result2 = client
            .send_message(chat_id, "Test2".to_string(), None, None)
            .await;
        assert!(result2.is_ok());
    }
}