use crate::{
    db::UserId,
    llm::{
        db::{queries::providers::ModelParams, LlmDatabase, TokenUsage},
        FREE_TIER_MONTHLY_SPENDING_LIMIT,
    },
    test_llm_db, Cents,
};
use chrono::{DateTime, Utc};
use pretty_assertions::assert_eq;
use rpc::LanguageModelProvider;

test_llm_db!(
    test_billing_limit_exceeded,
    test_billing_limit_exceeded_postgres
);

async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
    let provider = LanguageModelProvider::Anthropic;
    let model = "fake-claude-limerick";
    const PRICE_PER_MILLION_INPUT_TOKENS: i32 = 5;
    const PRICE_PER_MILLION_OUTPUT_TOKENS: i32 = 5;

    // Initialize the database and insert the model
    db.initialize().await.unwrap();
    db.insert_models(&[ModelParams {
        provider,
        name: model.to_string(),
        max_requests_per_minute: 5,
        max_tokens_per_minute: 10_000,
        max_tokens_per_day: 50_000,
        price_per_million_input_tokens: PRICE_PER_MILLION_INPUT_TOKENS,
        price_per_million_output_tokens: PRICE_PER_MILLION_OUTPUT_TOKENS,
    }])
    .await
    .unwrap();

    // Set a fixed datetime for consistent testing
    let now = DateTime::parse_from_rfc3339("2024-08-08T22:46:33Z")
        .unwrap()
        .with_timezone(&Utc);

    let user_id = UserId::from_proto(123);

    let max_monthly_spend = Cents::from_dollars(11);

    // Record usage that brings us close to the limit but doesn't exceed it
    // Let's say we use $10.50 worth of tokens
    let tokens_to_use = 210_000_000; // This will cost $10.50 at $0.05 per 1 million tokens
    let usage = TokenUsage {
        input: tokens_to_use,
        input_cache_creation: 0,
        input_cache_read: 0,
        output: 0,
    };

    // Verify that before we record any usage, there are 0 billing events
    let billing_events = db.get_billing_events().await.unwrap();
    assert_eq!(billing_events.len(), 0);

    db.record_usage(
        user_id,
        false,
        provider,
        model,
        usage,
        true,
        max_monthly_spend,
        FREE_TIER_MONTHLY_SPENDING_LIMIT,
        now,
    )
    .await
    .unwrap();

    // Verify the recorded usage and spending
    let recorded_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
    // Verify that we exceeded the free tier usage
    assert_eq!(recorded_usage.spending_this_month, Cents::new(1050));
    assert!(recorded_usage.spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT);

    // Verify that there is one `billing_event` record
    let billing_events = db.get_billing_events().await.unwrap();
    assert_eq!(billing_events.len(), 1);

    let (billing_event, _model) = &billing_events[0];
    assert_eq!(billing_event.user_id, user_id);
    assert_eq!(billing_event.input_tokens, tokens_to_use as i64);
    assert_eq!(billing_event.input_cache_creation_tokens, 0);
    assert_eq!(billing_event.input_cache_read_tokens, 0);
    assert_eq!(billing_event.output_tokens, 0);

    // Record usage that puts us at $20.50
    let usage_2 = TokenUsage {
        input: 200_000_000, // This will cost $10 more, pushing us from $10.50 to $20.50,
        input_cache_creation: 0,
        input_cache_read: 0,
        output: 0,
    };
    db.record_usage(
        user_id,
        false,
        provider,
        model,
        usage_2,
        true,
        max_monthly_spend,
        FREE_TIER_MONTHLY_SPENDING_LIMIT,
        now,
    )
    .await
    .unwrap();

    // Verify the updated usage and spending
    let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
    assert_eq!(updated_usage.spending_this_month, Cents::new(2050));

    // Verify that there are now two billing events
    let billing_events = db.get_billing_events().await.unwrap();
    assert_eq!(billing_events.len(), 2);

    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $20.50 to $21.50, which is over the $11 monthly maximum limit
    let usage_exceeding = TokenUsage {
        input: tokens_to_exceed,
        input_cache_creation: 0,
        input_cache_read: 0,
        output: 0,
    };

    // This should still create a billing event as it's the first request that exceeds the limit
    db.record_usage(
        user_id,
        false,
        provider,
        model,
        usage_exceeding,
        true,
        FREE_TIER_MONTHLY_SPENDING_LIMIT,
        max_monthly_spend,
        now,
    )
    .await
    .unwrap();
    // Verify the updated usage and spending
    let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
    assert_eq!(updated_usage.spending_this_month, Cents::new(2150));

    // Verify that we never exceed the user max spending for the user
    // and avoid charging them.
    let billing_events = db.get_billing_events().await.unwrap();
    assert_eq!(billing_events.len(), 2);
}