mod common;

use common::test_context::TestContext;
use diesel::{Connection, SqliteConnection};
use schist_fakes::{
    bucket::make_fake_bucket, bucket_transaction::make_fake_bucket_transaction_builder,
};
use schist_queries as queries;

#[test]
fn when_insert_bucket_transactions_then_returns_num_bucket_transactions() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
    let bucket_transactions = [
        make_fake_bucket_transaction_builder(0)
            .bucket_id(0)
            .build()
            .unwrap(),
        make_fake_bucket_transaction_builder(1)
            .bucket_id(1)
            .build()
            .unwrap(),
    ];
    let _ = queries::buckets::insert_buckets(&buckets, connection);

    let num_bucket_transactions_inserted =
        queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
            .unwrap();

    assert_eq!(num_bucket_transactions_inserted, 2);
}

#[test]
fn given_bucket_transactions_when_get_all_bucket_transactions_then_return_bucket_transactions() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
    let bucket_transactions = [
        make_fake_bucket_transaction_builder(0)
            .bucket_id(0)
            .build()
            .unwrap(),
        make_fake_bucket_transaction_builder(1)
            .bucket_id(1)
            .build()
            .unwrap(),
    ];
    let _ = queries::buckets::insert_buckets(&buckets, connection);
    let _ =
        queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
            .unwrap();

    let bucket_transactions_in_db =
        queries::bucket_transactions::get_all_bucket_transactions(connection).unwrap();

    assert_eq!(bucket_transactions_in_db.len(), bucket_transactions.len());
    for bucket_transaction in &bucket_transactions {
        assert!(bucket_transactions_in_db
            .iter()
            .any(|bucket_transaction_in_db| bucket_transaction_in_db.eq(&bucket_transaction)));
    }
    for bucket_transaction_in_db in bucket_transactions_in_db {
        assert!(bucket_transactions
            .iter()
            .any(|bucket_transaction| bucket_transaction.eq(&bucket_transaction_in_db)));
    }
}

#[test]
fn given_bucket_transactions_when_delete_all_bucket_transactions_then_return_num_of_bucket_transactions(
) {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
    let bucket_transactions = [
        make_fake_bucket_transaction_builder(0)
            .bucket_id(0)
            .build()
            .unwrap(),
        make_fake_bucket_transaction_builder(1)
            .bucket_id(1)
            .build()
            .unwrap(),
    ];
    let _ = queries::buckets::insert_buckets(&buckets, connection);
    let _ =
        queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
            .unwrap();

    let num_bucket_transactions_deleted =
        queries::bucket_transactions::delete_all_bucket_transactions(connection).unwrap();

    assert_eq!(num_bucket_transactions_deleted, bucket_transactions.len());
}

#[test]
fn given_deleted_bucket_transactions_when_get_all_bucket_transactions_then_return_empty() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
    let bucket_transactions = [
        make_fake_bucket_transaction_builder(0)
            .bucket_id(0)
            .build()
            .unwrap(),
        make_fake_bucket_transaction_builder(1)
            .bucket_id(1)
            .build()
            .unwrap(),
    ];
    let _ = queries::buckets::insert_buckets(&buckets, connection);
    let _ =
        queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
            .unwrap();
    let _ = queries::bucket_transactions::delete_all_bucket_transactions(connection).unwrap();

    let bucket_transactions_returned =
        queries::bucket_transactions::get_all_bucket_transactions(connection).unwrap();

    assert_eq!(bucket_transactions_returned.len(), 0);
}

#[test]
fn given_bucket_transactions_when_sum_amount_per_bucket_id_then_returns_sum_per_bucket_id() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
    let bucket_transactions = [
        make_fake_bucket_transaction_builder(0)
            .bucket_id(0)
            .amount(1)
            .build()
            .unwrap(),
        make_fake_bucket_transaction_builder(1)
            .bucket_id(0)
            .amount(2)
            .build()
            .unwrap(),
        make_fake_bucket_transaction_builder(2)
            .bucket_id(1)
            .amount(4)
            .build()
            .unwrap(),
    ];
    let _ = queries::buckets::insert_buckets(&buckets, connection);
    let _ =
        queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
            .unwrap();

    let sums =
        queries::bucket_transactions::sum_bucket_transaction_amount_per_bucket_id(connection);

    assert!(sums.is_ok());
    let mut sums = sums.unwrap();
    sums.sort_by_key(|sum| sum.0);
    assert_eq!(buckets.len(), sums.len());
    assert_eq!(3, sums[0].1);
    assert_eq!(4, sums[1].1);
}