db/heromodels/examples/test_reminder_functionality.rs

use heromodels::models::legal::{ContractSigner, SignerStatus};

// Helper function to get current timestamp
fn current_timestamp_secs() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs()
}

fn main() {
    println!("Testing ContractSigner Reminder Functionality");
    println!("==============================================\n");

    // Test 1: Create a new signer (should have no reminder timestamp)
    println!("Test 1: New signer creation");
    let mut signer = ContractSigner::new(
        "test-signer-001".to_string(),
        "Test User".to_string(),
        "test@example.com".to_string(),
    );

    println!("  Signer created: {}", signer.name);
    println!("  Last reminder: {:?}", signer.last_reminder_mail_sent_at);
    assert_eq!(signer.last_reminder_mail_sent_at, None);
    println!("  ✓ New signer has no reminder timestamp\n");

    // Test 2: Check if reminder can be sent (should be true for new signer)
    println!("Test 2: Can send reminder check");
    let current_time = current_timestamp_secs();
    let can_send = signer.can_send_reminder(current_time);
    println!("  Can send reminder: {}", can_send);
    assert!(can_send);
    println!("  ✓ New signer can receive reminders\n");

    // Test 3: Check cooldown remaining (should be None for new signer)
    println!("Test 3: Cooldown remaining check");
    let cooldown = signer.reminder_cooldown_remaining(current_time);
    println!("  Cooldown remaining: {:?}", cooldown);
    assert_eq!(cooldown, None);
    println!("  ✓ New signer has no cooldown\n");

    // Test 4: Mark reminder as sent
    println!("Test 4: Mark reminder as sent");
    signer.mark_reminder_sent(current_time);
    println!("  Reminder marked as sent at: {}", current_time);
    println!(
        "  Last reminder timestamp: {:?}",
        signer.last_reminder_mail_sent_at
    );
    assert_eq!(signer.last_reminder_mail_sent_at, Some(current_time));
    println!("  ✓ Reminder timestamp updated correctly\n");

    // Test 5: Check if reminder can be sent immediately after (should be false)
    println!("Test 5: Immediate retry check");
    let can_send_again = signer.can_send_reminder(current_time);
    println!("  Can send reminder immediately: {}", can_send_again);
    assert!(!can_send_again);
    println!("  ✓ Cannot send reminder immediately after sending\n");

    // Test 6: Check cooldown remaining (should be 30 minutes)
    println!("Test 6: Cooldown after sending");
    let cooldown_after = signer.reminder_cooldown_remaining(current_time);
    println!("  Cooldown remaining: {:?} seconds", cooldown_after);
    assert_eq!(cooldown_after, Some(30 * 60)); // 30 minutes = 1800 seconds
    println!("  ✓ Cooldown is exactly 30 minutes\n");

    // Test 7: Test after cooldown period
    println!("Test 7: After cooldown period");
    let future_time = current_time + (31 * 60); // 31 minutes later
    let can_send_later = signer.can_send_reminder(future_time);
    let cooldown_later = signer.reminder_cooldown_remaining(future_time);
    println!("  Time: {} (31 minutes later)", future_time);
    println!("  Can send reminder: {}", can_send_later);
    println!("  Cooldown remaining: {:?}", cooldown_later);
    assert!(can_send_later);
    assert_eq!(cooldown_later, None);
    println!("  ✓ Can send reminder after cooldown period\n");

    // Test 8: Test builder pattern with reminder timestamp
    println!("Test 8: Builder pattern with reminder timestamp");
    let signer_with_reminder = ContractSigner::new(
        "test-signer-002".to_string(),
        "Another User".to_string(),
        "another@example.com".to_string(),
    )
    .status(SignerStatus::Pending)
    .last_reminder_mail_sent_at(current_time - (20 * 60)) // 20 minutes ago
    .comments("Test signer with reminder");

    println!("  Signer: {}", signer_with_reminder.name);
    println!(
        "  Last reminder: {:?}",
        signer_with_reminder.last_reminder_mail_sent_at
    );
    println!(
        "  Can send reminder: {}",
        signer_with_reminder.can_send_reminder(current_time)
    );

    let remaining = signer_with_reminder.reminder_cooldown_remaining(current_time);
    println!("  Cooldown remaining: {:?} seconds", remaining);
    assert_eq!(remaining, Some(10 * 60)); // 10 minutes remaining
    println!("  ✓ Builder pattern works correctly\n");

    // Test 9: Test clear reminder timestamp
    println!("Test 9: Clear reminder timestamp");
    let cleared_signer = signer_with_reminder.clear_last_reminder_mail_sent_at();
    println!(
        "  Last reminder after clear: {:?}",
        cleared_signer.last_reminder_mail_sent_at
    );
    println!(
        "  Can send reminder: {}",
        cleared_signer.can_send_reminder(current_time)
    );
    assert_eq!(cleared_signer.last_reminder_mail_sent_at, None);
    assert!(cleared_signer.can_send_reminder(current_time));
    println!("  ✓ Clear reminder timestamp works correctly\n");

    println!("All tests passed! ✅");
    println!("ContractSigner reminder functionality is working correctly.");
}