mod common;

use common::test_context::TestContext;
use diesel::{Connection, SqliteConnection};
use schist_fakes::{
    account::make_fake_account, bucket::make_fake_bucket, pipe::make_fake_pipe_builder,
    transaction::make_fake_transaction_builder,
};
use schist_models::{Account, Bucket, Transaction};
use schist_queries as queries;

fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> {
    let accounts = vec![make_fake_account(0)];
    let _ = queries::accounts::insert_accounts(&accounts, connection);
    accounts
}

fn given_buckets(connection: &mut SqliteConnection) -> Vec<Bucket> {
    let buckets = vec![make_fake_bucket(0), make_fake_bucket(1)];
    let _ = queries::buckets::insert_buckets(&buckets, connection);
    buckets
}

fn given_transactions(connection: &mut SqliteConnection) -> Vec<Transaction> {
    let transactions = vec![
        make_fake_transaction_builder(0)
            .account_id(0)
            .build()
            .unwrap(),
        make_fake_transaction_builder(1)
            .account_id(0)
            .build()
            .unwrap(),
    ];
    let _ = queries::transactions::insert_transactions(&transactions, connection);
    transactions
}

#[test]
fn when_insert_pipes_then_returns_num_pipes() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    given_accounts(connection);
    given_buckets(connection);
    given_transactions(connection);
    let pipes = [
        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
    ];

    let num_pipes_inserted = queries::pipes::insert_pipes(&pipes, connection).unwrap();

    assert_eq!(num_pipes_inserted, 2);
}

#[test]
fn given_pipes_when_get_all_pipes_then_return_pipes() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    given_accounts(connection);
    given_buckets(connection);
    given_transactions(connection);
    let pipes = [
        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
    ];
    let _ = queries::pipes::insert_pipes(&pipes, connection);

    let pipes_in_db = queries::pipes::get_all_pipes(connection).unwrap();

    assert_eq!(pipes_in_db.len(), pipes.len());
    for pipe in &pipes {
        assert!(pipes_in_db.iter().any(|pipe_in_db| pipe_in_db.eq(&pipe)));
    }
    for pipe_in_db in pipes_in_db {
        assert!(pipes.iter().any(|pipe| pipe.eq(&pipe_in_db)));
    }
}

#[test]
fn given_pipes_when_delete_all_pipes_then_return_num_of_pipes() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    given_accounts(connection);
    given_buckets(connection);
    given_transactions(connection);
    let pipes = [
        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
    ];
    let _ = queries::pipes::insert_pipes(&pipes, connection);

    let num_pipes_deleted = queries::pipes::delete_all_pipes(connection).unwrap();

    assert_eq!(num_pipes_deleted, pipes.len());
}

#[test]
fn given_deleted_pipes_when_get_all_pipes_then_return_empty() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    given_accounts(connection);
    given_buckets(connection);
    given_transactions(connection);
    let pipes = [
        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
    ];
    let _ = queries::pipes::insert_pipes(&pipes, connection);
    let _ = queries::pipes::delete_all_pipes(connection);

    let pipes_returned = queries::pipes::get_all_pipes(connection).unwrap();

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

#[test]
fn given_pipes_when_sum_amount_per_bucket_id_then_returns_sum_amount_per_bucket_id() {
    let context = TestContext::new();
    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
    given_accounts(connection);
    let buckets = given_buckets(connection);
    given_transactions(connection);
    let pipes = [
        make_fake_pipe_builder(0)
            .bucket_id(0)
            .amount(1)
            .build()
            .unwrap(),
        make_fake_pipe_builder(1)
            .bucket_id(0)
            .amount(2)
            .build()
            .unwrap(),
        make_fake_pipe_builder(2)
            .bucket_id(1)
            .amount(4)
            .build()
            .unwrap(),
    ];
    let _ = queries::pipes::insert_pipes(&pipes, connection);

    let sums = queries::pipes::sum_pipes_flow_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);
}