use std::sync::Arc;
use application::testing::{InMemoryQuotaRepository, InMemoryUsageLedgerRepository};
use application::storage::{CheckQuotaQuery, CheckQuotaHandler};
use domain::entities::{QuotaDefinition, TimePeriod, UsageLedgerEntry, UsageType};
use domain::ports::UsageLedgerRepository;
use domain::value_objects::SystemId;

#[tokio::test]
async fn returns_allowed() {
    let quota_repo = Arc::new(InMemoryQuotaRepository::new());
    let ledger_repo = Arc::new(InMemoryUsageLedgerRepository::new());

    let user = SystemId::new();
    let mut quota = QuotaDefinition::new(user);
    quota.add_rule(UsageType::StorageBytes, 10_000, TimePeriod::Lifetime);
    use domain::ports::QuotaRepository;
    quota_repo.save(&quota).await.unwrap();

    let handler = CheckQuotaHandler::new(quota_repo, ledger_repo);
    let result = handler.execute(CheckQuotaQuery {
        user_id: user,
        usage_type: UsageType::StorageBytes,
        requested_amount: 5_000,
    }).await.unwrap();

    assert!(result.allowed);
    assert_eq!(result.limit, 10_000);
    assert!(!result.is_unlimited);
}

#[tokio::test]
async fn returns_denied() {
    let quota_repo = Arc::new(InMemoryQuotaRepository::new());
    let ledger_repo = Arc::new(InMemoryUsageLedgerRepository::new());

    let user = SystemId::new();
    let mut quota = QuotaDefinition::new(user);
    quota.add_rule(UsageType::StorageBytes, 1_000, TimePeriod::Lifetime);
    use domain::ports::QuotaRepository;
    quota_repo.save(&quota).await.unwrap();

    // record existing usage
    let entry = UsageLedgerEntry::new(user, UsageType::StorageBytes, 900, "prior upload");
    ledger_repo.record(&entry).await.unwrap();

    let handler = CheckQuotaHandler::new(quota_repo, ledger_repo);
    let result = handler.execute(CheckQuotaQuery {
        user_id: user,
        usage_type: UsageType::StorageBytes,
        requested_amount: 200,
    }).await.unwrap();

    assert!(!result.allowed);
    assert_eq!(result.current_usage, 900);
}

#[tokio::test]
async fn returns_unlimited_when_no_quota() {
    let quota_repo = Arc::new(InMemoryQuotaRepository::new());
    let ledger_repo = Arc::new(InMemoryUsageLedgerRepository::new());

    let handler = CheckQuotaHandler::new(quota_repo, ledger_repo);
    let result = handler.execute(CheckQuotaQuery {
        user_id: SystemId::new(),
        usage_type: UsageType::StorageBytes,
        requested_amount: 999_999,
    }).await.unwrap();

    assert!(result.allowed);
    assert!(result.is_unlimited);
}