refluxer 0.2.0

mod common;
use common::{setup, start_gateway_session};
use refluxer::http::endpoints::guilds::CreateGuildChannel;
use refluxer::http::endpoints::messages::{CreateMessage, EditMessage};
use refluxer::model::message::Embed;

#[tokio::test]
async fn test_message_send_edit_get_delete() {
    let (http, guild_id) = setup();
    let _gw = start_gateway_session().await;

    let channel = http
        .create_guild_channel(
            guild_id,
            &CreateGuildChannel::text("refluxer-test-messages"),
        )
        .await
        .expect("create channel for messages failed");

    let msg = http
        .create_message(channel.id, &CreateMessage::text("Hello from refluxer!"))
        .await
        .expect("create_message failed");

    assert_eq!(msg.content, "Hello from refluxer!");
    assert_eq!(msg.channel_id, channel.id);
    println!("Sent message: {} (id: {})", msg.content, msg.id);

    let fetched = http
        .get_message(channel.id, msg.id)
        .await
        .expect("get_message failed");
    assert_eq!(fetched.id, msg.id);
    assert_eq!(fetched.content, "Hello from refluxer!");

    let edited = http
        .edit_message(
            channel.id,
            msg.id,
            &EditMessage {
                content: Some("Edited by refluxer!".into()),
                ..Default::default()
            },
        )
        .await
        .expect("edit_message failed");

    assert_eq!(edited.content, "Edited by refluxer!");
    assert!(
        edited.edited_timestamp.is_some(),
        "edited_timestamp should be set"
    );

    http.delete_message(channel.id, msg.id)
        .await
        .expect("delete_message failed");

    let result = http.get_message(channel.id, msg.id).await;
    assert!(result.is_err(), "message should be deleted");

    http.delete_channel(channel.id)
        .await
        .expect("cleanup channel failed");
}

#[tokio::test]
async fn test_get_messages_list() {
    let (http, guild_id) = setup();
    let _gw = start_gateway_session().await;

    let channel = http
        .create_guild_channel(guild_id, &CreateGuildChannel::text("refluxer-test-list"))
        .await
        .expect("create channel failed");

    for i in 1..=3 {
        http.create_message(channel.id, &CreateMessage::text(format!("Message {i}")))
            .await
            .expect("create_message failed");
    }

    let messages = http
        .get_messages(channel.id)
        .await
        .expect("get_messages failed");

    assert!(
        messages.len() >= 3,
        "should have at least 3 messages, got {}",
        messages.len()
    );
    println!("Channel has {} messages", messages.len());

    http.delete_channel(channel.id)
        .await
        .expect("cleanup channel failed");
}

#[tokio::test]
async fn test_message_with_embed() {
    let (http, guild_id) = setup();
    let _gw = start_gateway_session().await;

    let channel = http
        .create_guild_channel(guild_id, &CreateGuildChannel::text("refluxer-test-embed"))
        .await
        .expect("create channel failed");

    let embed = Embed {
        kind: Some("rich".into()),
        title: Some("Test Embed".into()),
        description: Some("This is a test embed from refluxer".into()),
        color: Some(0x00FF00),
        url: None,
        timestamp: None,
        footer: None,
        image: None,
        thumbnail: None,
        video: None,
        author: None,
        fields: None,
    };

    let msg = http
        .create_message(
            channel.id,
            &CreateMessage {
                content: Some("Message with embed".into()),
                embeds: Some(vec![embed]),
                ..Default::default()
            },
        )
        .await
        .expect("create_message with embed failed");

    assert_eq!(msg.content, "Message with embed");
    let embeds = msg.embeds.as_ref().expect("message should have embeds");
    assert!(!embeds.is_empty(), "should have at least one embed");
    assert_eq!(embeds[0].title.as_deref(), Some("Test Embed"));

    http.delete_channel(channel.id)
        .await
        .expect("cleanup channel failed");
}

#[tokio::test]
async fn test_message_builder_with_embed_and_reply() {
    let (http, guild_id) = setup();
    let _gw = start_gateway_session().await;

    let channel = http
        .create_guild_channel(guild_id, &CreateGuildChannel::text("refluxer-test-builder"))
        .await
        .expect("create channel failed");

    let original = http
        .create_message(channel.id, &CreateMessage::text("Original message"))
        .await
        .expect("create_message failed");

    let reply = http
        .create_message(
            channel.id,
            &CreateMessage::new()
                .content("Reply with embed!")
                .reply(original.id)
                .embed(|e| {
                    e.title("Test Embed")
                        .description("Built with EmbedBuilder")
                        .color(0x00CCFF)
                        .field("Field 1", "Value 1", true)
                        .field("Field 2", "Value 2", true)
                        .footer("refluxer integration test")
                }),
        )
        .await
        .expect("create_message with builder failed");

    assert_eq!(reply.content, "Reply with embed!");
    assert!(
        reply.message_reference.is_some(),
        "should have message_reference"
    );
    let embeds = reply.embeds.as_ref().expect("should have embeds");
    assert_eq!(embeds.len(), 1);
    assert_eq!(embeds[0].title.as_deref(), Some("Test Embed"));
    let fields = embeds[0].fields.as_ref().expect("embed should have fields");
    assert_eq!(fields.len(), 2);

    println!("Message builder test passed");

    http.delete_channel(channel.id)
        .await
        .expect("cleanup channel failed");
}

#[tokio::test]
async fn test_bulk_delete_messages() {
    let (http, guild_id) = setup();
    let _gw = start_gateway_session().await;

    let channel = http
        .create_guild_channel(guild_id, &CreateGuildChannel::text("refluxer-test-bulk"))
        .await
        .expect("create channel failed");

    let mut ids = Vec::new();
    for i in 1..=3 {
        let msg = http
            .create_message(channel.id, &CreateMessage::text(format!("Bulk {i}")))
            .await
            .expect("create_message failed");
        ids.push(msg.id);
    }

    http.bulk_delete_messages(channel.id, &ids)
        .await
        .expect("bulk_delete_messages failed");

    let remaining = http
        .get_messages(channel.id)
        .await
        .expect("get_messages failed");
    for id in &ids {
        assert!(
            !remaining.iter().any(|m| m.id == *id),
            "bulk-deleted message should not remain"
        );
    }

    println!("Bulk delete test passed");

    http.delete_channel(channel.id)
        .await
        .expect("cleanup channel failed");
}