#ifdef _WIN32
    #include <io.h>     // for _unlink
    #define unlink _unlink
#else
    #include <unistd.h> // for unlink
#endif

static void setup_cb(void *data) {
    (void)data;
    unlink(test_file_path);
}

static void teardown_cb(void *data) {
    (void)data;
    unlink(test_file_path);
}

TEST _administration_rw_taxrate(void)
{ 
    tax_rate pw;
    tax_rate pr;
    u32 count;

    administration_writer::create();

    administration_create_empty(test_file_path);
    {
        pw = administration_tax_rate_create_empty();
        strops::copy(pw.country_code, "NL", sizeof(pw.country_code));
        pw.rate = 10.0f;
        strops::copy(pw.category_code, "S", sizeof(pw.category_code));
        
        count = administration_tax_rate_count();
        administration_tax_rate_add(pw);

        ASSERT_EQ(count+1, administration_tax_rate_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_tax_rate_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_tax_rate_get_by_id(&pr, pw.id));
        ASSERT_MEM_EQ(&pw, &pr, sizeof(tax_rate));
    }

    PASS();
}

TEST _administration_rw_costcenter(void)
{
    cost_center pw;
    cost_center pr;
    u32 count;

    administration_writer::create();

    administration_create_empty(test_file_path);
    {
        pw = administration_cost_center_create_empty();
        strops::copy(pw.code, "CODE", sizeof(pw.code));
        strops::copy(pw.description, "Description", sizeof(pw.description));
        
        count = administration_cost_center_count();
        administration_cost_center_add(pw);

        ASSERT_EQ(count+1, administration_cost_center_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_cost_center_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_cost_center_get_by_id(&pr, pw.id));
        ASSERT_MEM_EQ(&pw, &pr, sizeof(cost_center));
    }

    PASS();
}

TEST _administration_rw_project(void)
{
    project pw;
    project pr;
    u32 count;

    administration_writer::create();

    administration_create_empty(test_file_path);
    {
        pw = administration_project_create_empty();
        strops::copy(pw.description, "Test Project", sizeof(pw.description));
        count = administration_project_count();
        administration_project_add(pw);

        ASSERT_EQ(count+1, administration_project_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_project_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_project_get_by_id(&pr, pw.id));
        ASSERT_MEM_EQ(&pw, &pr, sizeof(project));
    }

    PASS();
}

TEST _administration_rw_contact(void)
{
    contact pw;
    contact pr;
    u32 count;

    administration_writer::create();

    administration_create_empty(test_file_path);
    {
        pw = administration_contact_create_empty();
        strops::copy(pw.name, "John Johnsson", sizeof(pw.name));
        strops::copy(pw.address.address1, "Address 1", sizeof(pw.address.address1));
        strops::copy(pw.address.country_code, "FR", sizeof(pw.address.country_code));
        strops::copy(pw.address.city, "Paris", sizeof(pw.address.city));
        strops::copy(pw.address.postal, "12345", sizeof(pw.address.postal));
        strops::copy(pw.email, "test@test.com", sizeof(pw.email));
        pw.type = contact_type::CONTACT_CONSUMER;

        count = administration_contact_count();
        administration_contact_add(pw);

        ASSERT_EQ(count+1, administration_contact_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_contact_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_contact_get_by_id(&pr, pw.id));
        ASSERT_MEM_EQ(&pw, &pr, sizeof(contact));
    }

    PASS();
}

TEST _administration_rw_info(void)
{
    administration_writer::create();

    s32 next_id, next_sequence_number;
    ai_service ais;
    administration_create_empty(test_file_path);
    {
        next_id = administration_get_next_id();
        next_sequence_number = administration_get_next_sequence_number();

        ai_service ss = {0};
        ss.provider = AI_PROVIDER_OPENAI;
        strops::copy(ss.api_key_public, "123", sizeof(ss.api_key_public));
        administration_set_ai_service(ss);

        ais = administration_get_ai_service();
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(next_id, administration_get_next_id());
        ASSERT_EQ(next_sequence_number, administration_get_next_sequence_number());

        ai_service rs = administration_get_ai_service();
        ASSERT_MEM_EQ(&ais, &rs, sizeof(ai_service));
    }

    PASS();
}

TEST _assert_invoices_are_equal(invoice inv, invoice invr)
{
    ASSERT_STR_EQ(invr.id, inv.id);
    ASSERT_STR_EQ(invr.sequential_number, inv.sequential_number);

    ASSERT_EQ(invr.issued_at, inv.issued_at);
    ASSERT_EQ(invr.expires_at, inv.expires_at);
    ASSERT_EQ(invr.delivered_at, inv.delivered_at);
    ASSERT_STR_EQ(invr.document.original_path, inv.document.original_path);
    ASSERT_STR_EQ(invr.document.copy_path, inv.document.copy_path);
    ASSERT_STR_EQ(invr.project_id, inv.project_id);
    ASSERT_STR_EQ(invr.cost_center_id, inv.cost_center_id);

    ASSERT_EQ(administration_billing_item_count(&inv), administration_billing_item_count(&invr));

    int num_items = administration_billing_item_count(&inv);
    for (int i = 0; i < num_items; i++)
    {
        billing_item* b1 = (billing_item*)list_get_at(&inv.billing_items, i);
        billing_item* b2 = (billing_item*)list_get_at(&invr.billing_items, i);

        ASSERT_STR_EQ(b1->id, b2->id);
        ASSERT_EQ(b1->amount, b2->amount);
        ASSERT_EQ(b1->amount_is_percentage, b2->amount_is_percentage);
        ASSERT_STR_EQ(b1->description, b2->description);
        ASSERT_EQ(b1->net_per_item, b2->net_per_item);
        ASSERT_EQ(b1->discount, b2->discount);
        ASSERT_EQ(b1->discount_is_percentage, b2->discount_is_percentage);
        ASSERT_EQ(b1->allowance, b2->allowance);
        ASSERT_EQ(b1->net, b2->net);
        ASSERT_STR_EQ(b1->currency, b2->currency);
        ASSERT_STR_EQ(b1->tax_rate_id, b2->tax_rate_id);
        ASSERT_EQ(b1->tax, b2->tax);
        ASSERT_EQ(b1->total, b2->total);
    }

    ASSERT_EQ(invr.orig_total, inv.orig_total);
    ASSERT_EQ(invr.orig_tax, inv.orig_tax);
    ASSERT_EQ(invr.orig_net, inv.orig_net);
    ASSERT_EQ(invr.orig_allowance, inv.orig_allowance);

    ASSERT_EQ(invr.total, inv.total);
    ASSERT_EQ(invr.tax, inv.tax);
    ASSERT_EQ(invr.net, inv.net);
    ASSERT_EQ(invr.allowance, inv.allowance);

    ASSERT_STR_EQ(invr.currency, inv.currency);
    ASSERT_EQ(invr.is_triangulation, inv.is_triangulation);
    ASSERT_EQ(invr.status, inv.status);
    ASSERT_EQ(invr.is_outgoing, inv.is_outgoing);
    ASSERT_MEM_EQ(&invr.payment_means, &inv.payment_means, sizeof(payment_information));
    ASSERT_MEM_EQ(&invr.supplier, &inv.supplier, sizeof(delivery_info));
    ASSERT_MEM_EQ(&invr.customer, &inv.customer, sizeof(delivery_info));
    ASSERT_MEM_EQ(&invr.addressee, &inv.addressee, sizeof(delivery_info));

    PASS();
}

TEST _administration_rw_b2b_invoice(void)
{
    u32 count;
    invoice inv;
    invoice invr;

    administration_writer::create();

    administration_create_default(test_file_path);
    {
        contact pw1 = _create_nl_business();
        contact pw2 = _create_nl_business();

        inv = administration_invoice_create_empty();
        inv.supplier = pw1;
        inv.customer = pw2;
        inv.is_outgoing = 1;
        inv.status = invoice_status::INVOICE_CONCEPT;
        inv.issued_at = time(NULL);
        inv.delivered_at = inv.issued_at;
        inv.expires_at = inv.issued_at + 1000;

        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));

        count = administration_invoice_count();
        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
        ASSERT_EQ(count+1, administration_invoice_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_invoice_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));

        CHECK_CALL(_assert_invoices_are_equal(inv, invr));
    }

    PASS();
}

TEST _administration_rw_b2c_invoice(void)
{
    u32 count;
    invoice inv;
    invoice invr;

    administration_writer::create();

    administration_create_default(test_file_path);
    {
        contact pw1 = _create_nl_business();
        contact pw2 = _create_nl_consumer();

        inv = administration_invoice_create_empty();
        inv.supplier = pw1;
        inv.customer = pw2;
        inv.is_outgoing = 1;
        inv.status = invoice_status::INVOICE_CONCEPT;
        inv.issued_at = time(NULL);
        inv.delivered_at = inv.issued_at;
        inv.expires_at = inv.issued_at + 1000;

        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));

        count = administration_invoice_count();
        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
        ASSERT_EQ(count+1, administration_invoice_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_invoice_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));

        CHECK_CALL(_assert_invoices_are_equal(inv, invr));
    }

    PASS();
}

TEST _administration_rw_b2b2c_invoice(void)
{
    u32 count;
    invoice inv;
    invoice invr;

    administration_writer::create();

    administration_create_default(test_file_path);
    {
        inv = administration_invoice_create_empty();
        inv.supplier = _create_nl_business();
        inv.customer = _create_nl_business();
        strops::copy(inv.addressee.name, "Piet Pinda", sizeof(inv.addressee.name));
        inv.addressee.address = _create_nl_consumer().address;
        inv.is_triangulation = 1;
        inv.is_outgoing = 1;
        inv.status = invoice_status::INVOICE_CONCEPT;
        inv.issued_at = time(NULL);
        inv.delivered_at = inv.issued_at;
        inv.expires_at = inv.issued_at + 1000;

        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));

        count = administration_invoice_count();
        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
        ASSERT_EQ(count+1, administration_invoice_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_invoice_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));

        CHECK_CALL(_assert_invoices_are_equal(inv, invr));
    }

    PASS();
}

TEST _administration_rw_b2c_2currency_invoice(void)
{
    u32 count;
    invoice inv;
    invoice invr;

    administration_writer::create();

    administration_create_default(test_file_path);
    {
        contact pw1 = _create_nl_business();
        contact pw2 = _create_nl_consumer();

        inv = administration_invoice_create_empty();
        inv.supplier = pw1;
        inv.customer = pw2;
        inv.is_outgoing = 1;
        inv.status = invoice_status::INVOICE_CONCEPT;
        inv.issued_at = time(NULL);
        inv.delivered_at = inv.issued_at;
        inv.expires_at = inv.issued_at + 1000;

        administration_invoice_set_currency(&inv, "USD");

        administration_billing_item_add_to_invoice(&inv, _create_bi3(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi4(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi5(&inv));
        administration_billing_item_add_to_invoice(&inv, _create_bi6(&inv));

        // Finals are set manually for multi currency invoices.
        inv.total = 20.0f;
        inv.tax = 10.0f;
        inv.net = 10.0f;
        inv.allowance = 5.0f;

        count = administration_invoice_count();
        ASSERT_EQ(administration_invoice_add(&inv), A_ERR_SUCCESS);
        ASSERT_EQ(count+1, administration_invoice_count());
    }

    administration_reader::open_existing(test_file_path);
    {
        ASSERT_EQ(count+1, administration_invoice_count());
        ASSERT_EQ(A_ERR_SUCCESS, administration_invoice_get_by_id(&invr, inv.id));

        CHECK_CALL(_assert_invoices_are_equal(inv, invr));
    }

    PASS();
}

SUITE(administration_rw) {
    SET_SETUP(setup_cb, NULL);
    SET_TEARDOWN(teardown_cb, NULL);

    RUN_TEST(_administration_rw_taxrate);
    RUN_TEST(_administration_rw_costcenter);
    RUN_TEST(_administration_rw_project);
    RUN_TEST(_administration_rw_contact);
    RUN_TEST(_administration_rw_info);
    RUN_TEST(_administration_rw_b2b_invoice);
    RUN_TEST(_administration_rw_b2c_invoice);
    RUN_TEST(_administration_rw_b2b2c_invoice);
    RUN_TEST(_administration_rw_b2c_2currency_invoice);
}