use crate::{
    chat_database::ChatDatabase, 
    models::{
        conversation::{Conversation, ConversationBuilder},
        participant::Participant
    }
};

#[test]
fn test_database_init() {
    let _ = ChatDatabase::new_in_memory().unwrap();
}

#[test]
fn test_add_conversation() {
    let mut db = ChatDatabase::new_in_memory().unwrap();

    let guid = "test";
    let test_conversation = Conversation::builder()
        .guid(guid)
        .unread_count(2)
        .display_name("Test Conversation")
        .build();

    db.insert_conversation(test_conversation.clone()).unwrap();

    // Try to fetch with id now 
    let conversation = db.get_conversation_by_guid(guid).unwrap().unwrap();
    assert_eq!(conversation.guid, "test");

    // Modify the conversation and update it
    let modified_conversation = test_conversation.into_builder()
        .display_name("Modified Conversation")
        .build();

    db.insert_conversation(modified_conversation.clone()).unwrap();

    // Make sure we still only have one conversation. 
    let all_conversations = db.all_conversations().unwrap();
    assert_eq!(all_conversations.len(), 1);

    // And make sure the display name was updated 
    let conversation = db.get_conversation_by_guid(guid).unwrap().unwrap();
    assert_eq!(conversation.display_name.unwrap(), "Modified Conversation");
}

#[test]
fn test_conversation_participants() {
    let mut db = ChatDatabase::new_in_memory().unwrap();

    let participants: Vec<Participant> = vec!["one".into(), "two".into()];

    let guid = uuid::Uuid::new_v4().to_string();
    let conversation = ConversationBuilder::new()
        .guid(&guid)
        .display_name("Test")
        .participants(participants.clone())
        .build();

    db.insert_conversation(conversation).unwrap();

    let read_conversation = db.get_conversation_by_guid(&guid).unwrap().unwrap();
    let read_participants = read_conversation.participants;

    assert_eq!(participants, read_participants);

    // Try making another conversation with the same participants
    let conversation = ConversationBuilder::new()
        .display_name("A Different Test")
        .participants(participants.clone())
        .build();

    db.insert_conversation(conversation).unwrap();

    let read_conversation = db.get_conversation_by_guid(&guid).unwrap().unwrap();
    let read_participants: Vec<Participant> = read_conversation.participants;

    assert_eq!(participants, read_participants);
}

#[test]
fn test_all_conversations_with_participants() {
    let mut db = ChatDatabase::new_in_memory().unwrap();

    // Create two conversations with different participants
    let participants1: Vec<Participant> = vec!["one".into(), "two".into()];
    let participants2: Vec<Participant> = vec!["three".into(), "four".into()];

    let guid1 = uuid::Uuid::new_v4().to_string();
    let conversation1 = ConversationBuilder::new()
        .guid(&guid1)
        .display_name("Test 1")
        .participants(participants1.clone())
        .build();

    let guid2 = uuid::Uuid::new_v4().to_string();
    let conversation2 = ConversationBuilder::new()
        .guid(&guid2)
        .display_name("Test 2")
        .participants(participants2.clone())
        .build();

    // Insert both conversations
    db.insert_conversation(conversation1).unwrap();
    db.insert_conversation(conversation2).unwrap();

    // Get all conversations and verify the results
    let all_conversations = db.all_conversations().unwrap();
    assert_eq!(all_conversations.len(), 2);

    // Find and verify each conversation's participants
    let conv1 = all_conversations.iter().find(|c| c.guid == guid1).unwrap();
    let conv2 = all_conversations.iter().find(|c| c.guid == guid2).unwrap();

    assert_eq!(conv1.participants, participants1);
    assert_eq!(conv2.participants, participants2);
}