use crate::models::budgeting_app::{
    account::Account, budget_update::BudgetUpdate, category::Category,
    category_transfer::CategoryTransfer, transaction::Transaction,
    transaction_categorisation::TransactionCategorisation,
};
use sqlite::Connection;

pub fn insert_accounts(connection: &Connection, accounts: &[Account]) {
    for account in accounts {
        let str = format!(
            "
                insert into
                accounts(id, name, opening_balance, opening_date)
                values({0}, '{1}', {2}, '{3}');
            ",
            account.id,
            escape_str(&account.name),
            account.opening_balance,
            account.opening_date
        );
        connection.execute(str).unwrap();
    }
}

pub fn insert_categories(connection: &Connection, categories: &[Category]) {
    for category in categories {
        let str = format!(
            "
                insert into
                categories(id, name, initial_budget, initial_period)
                values({0}, '{1}', {2}, {3});
            ",
            category.id,
            escape_str(&category.name),
            category.initial_budget,
            category.initial_period,
        );
        connection.execute(str).unwrap();
    }
}

pub fn insert_budget_updates(connection: &Connection, budget_updates: &[BudgetUpdate]) {
    for budget_update in budget_updates {
        let str = format!(
            "
                insert into
                budget_updates(id, category_id, date, new_budget, new_period)
                values({0}, {1}, '{2}', {3}, {4});
            ",
            budget_update.id,
            budget_update.category_id,
            budget_update.date,
            budget_update.new_budget,
            budget_update.new_period,
        );
        connection.execute(str).unwrap();
    }
}

pub fn insert_transactions(connection: &Connection, transactions: &[Transaction]) {
    for transaction in transactions {
        let str = format!(
            "
                insert into
                transactions(id, description, payee, quantity, account_id)
                values({0}, '{1}', '{2}', {3}, {4});
             ",
            transaction.id,
            escape_str(&transaction.description),
            escape_str(&transaction.payee),
            transaction.quantity,
            transaction.account_id,
        );
        connection
            .execute(str.clone())
            .unwrap_or_else(|_| panic!("{}", &str.clone()));
    }
}

pub fn insert_transaction_categorisations(
    connection: &Connection,
    transaction_categorisations: &[TransactionCategorisation],
) {
    for transaction_categorisation in transaction_categorisations {
        let str = format!(
            "
                insert into
                transaction_categorisations(id, description, quantity, transaction_id, category_id)
                values({0}, '{1}', {2}, {3}, {4});
             ",
            transaction_categorisation.id,
            escape_str(&transaction_categorisation.description),
            transaction_categorisation.quantity,
            transaction_categorisation.transaction_id,
            transaction_categorisation.category_id,
        );
        connection.execute(str).unwrap();
    }
}

pub fn insert_category_transfers(connection: &Connection, category_transfers: &[CategoryTransfer]) {
    for category_transfer in category_transfers {
        let str = format!(
            "
                insert into
                category_transfers(id, description, quantity, from_category_id, to_category_id)
                values({0}, '{1}', {2}, {3}, {4});
             ",
            category_transfer.id,
            escape_str(&category_transfer.description),
            category_transfer.quantity,
            category_transfer.from_category_id,
            category_transfer.to_category_id,
        );
        connection.execute(str).unwrap();
    }
}

fn escape_str(str: &str) -> String {
    str.replace("'", "''")
}