#include <rtti.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unity.h>

#include "group.h"
#include "xce/types.h"
#include "xcelimit.h"
#include "xstring.h"

static void test_build_consumer1(void)
{
    xce_consumer_t*    c = NULL;
    var                mgr;
    xce_group_config_t gdata = {
        .members = { .count = 2, .data = (char*[]) { "rshen", "jsxing" } }
    };
    int  rc = 0;
    char buf[1024];

    groupmgr_init(&mgr, 4, 4);
    rc = build_consumer(&c, mgr, CONSUMER_USER, 1, &gdata, "user_group1");

    TEST_ASSERT_TRUE(rc == 1);

    rc = fmt_consumer(buf, sizeof(buf) - 1, c);
    TEST_ASSERT_TRUE(rc > 0);

    printf("\n >>> consumer: %s\n", buf);

    kill_consumer(c);

    destroy(mgr);

    return;
}

static void test_build_consumer2(void)
{
    xce_consumer_t*    c = NULL;
    var                mgr;
    xce_group_config_t gdata = {
        .members    = { .count = 1, .data = (char*[]) { "all" }             },
        .ex_members = { .count = 2, .data = (char*[]) { "rshen", "jsxing" } }
    };
    int  rc = 0;
    char buf[1024];

    groupmgr_init(&mgr, 4, 4);
    rc = build_consumer(&c, mgr, CONSUMER_USER, 1, &gdata, "user_group1");

    TEST_ASSERT_TRUE(rc == 1);

    rc = fmt_consumer(buf, sizeof(buf) - 1, c);

    TEST_ASSERT_TRUE(rc > 0);

    printf("\n >>> consumer: %s\n", buf);

    kill_consumer(c);

    destroy(mgr);

    return;
}

static void test_build_limit_ok1(void)
{
    var                umgr;
    var                qmgr;
    var                hmgr;
    var                pmgr;
    xce_limit_t*       limit;
    int                rc;
    xce_limit_config_t limit_config = {
        .name        = "limit1",
        .per_user    = 0,
        .per_queue   = 0,
        .per_project = 0,
        .per_host    = 0,
        .users
        = &(xce_group_config_t) { .members = { .count = 1,
                                               .data  = (char*[]) { "u1" } } },
        .queues   = NULL,
        .hosts    = NULL,
        .projects = NULL,
        .val
        = &(xce_limit_val_t) { .resname = "mem", .percent = 1, .val = 80.0 }
    };
    char buf[1024];

    groupmgr_init(&umgr, 4, 4);
    groupmgr_init(&qmgr, 4, 4);
    groupmgr_init(&hmgr, 4, 4);
    groupmgr_init(&pmgr, 4, 4);

    rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
    TEST_ASSERT_TRUE(rc == 1);

    memset(buf, 0x0, sizeof(buf));

    rc = fmt_limit(buf, sizeof(buf) - 1, limit);
    TEST_ASSERT_TRUE(rc > 0);

    printf("%s\n", buf);

    kill_limit(limit);

    destroy(pmgr);
    destroy(hmgr);
    destroy(qmgr);
    destroy(umgr);
}

static void test_match_limit_ok1(void)
{
    var                umgr;
    var                qmgr;
    var                hmgr;
    var                pmgr;
    xce_limit_t*       limit;
    int                rc;
    xce_limit_config_t limit_config = {
        .name        = "limit1",
        .per_user    = 0,
        .per_queue   = 0,
        .per_project = 0,
        .per_host    = 0,
        .users
        = &(xce_group_config_t) { .members = { .count = 1,
                                               .data  = (char*[]) { "all" } } },
        .queues
        = &(xce_group_config_t) { .members = { .count = 1,
                                               .data  = (char*[]) { "all" } } },
        .hosts = NULL,
        .projects
        = &(xce_group_config_t) { .members = { .count = 1,
                                               .data  = (char*[]) { "all" } } },
        .val
        = &(xce_limit_val_t) { .resname = "mem", .percent = 1, .val = 80.0 }
    };
    char buf[1024];

    groupmgr_init(&umgr, 4, 4);
    groupmgr_init(&qmgr, 4, 4);
    groupmgr_init(&hmgr, 4, 4);
    groupmgr_init(&pmgr, 4, 4);

    rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
    TEST_ASSERT_TRUE(rc == 1);

    memset(buf, 0x0, sizeof(buf));

    rc = fmt_limit(buf, sizeof(buf) - 1, limit);
    TEST_ASSERT_TRUE(rc > 0);

    printf("%s\n", buf);

    rc = match_limit(limit, 1, "rshen", "xce", "project1");
    TEST_ASSERT_TRUE(rc > 0);

    kill_limit(limit);

    destroy(pmgr);
    destroy(hmgr);
    destroy(qmgr);
    destroy(umgr);
}

static void test_match_limit_ok2(void)
{
    var                umgr;
    var                qmgr;
    var                hmgr;
    var                pmgr;
    xce_limit_t*       limit;
    int                rc;
    xce_limit_config_t limit_config = {
        .name        = "limit1",
        .per_user    = 0,
        .per_queue   = 0,
        .per_project = 0,
        .per_host    = 0,
        .users       = NULL,
        .queues      = NULL,
        .hosts       = NULL,
        .projects    = NULL,
        .val
        = &(xce_limit_val_t) { .resname = "mem", .percent = 1, .val = 80.0 }
    };
    char buf[1024];

    groupmgr_init(&umgr, 4, 4);
    groupmgr_init(&qmgr, 4, 4);
    groupmgr_init(&hmgr, 4, 4);
    groupmgr_init(&pmgr, 4, 4);

    rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
    TEST_ASSERT_TRUE(rc == 1);

    memset(buf, 0x0, sizeof(buf));

    rc = fmt_limit(buf, sizeof(buf) - 1, limit);
    TEST_ASSERT_TRUE(rc > 0);

    printf("%s\n", buf);

    rc = match_limit(limit, 1, "rshen", "xce", "project1");
    TEST_ASSERT_TRUE(rc > 0);

    kill_limit(limit);

    destroy(pmgr);
    destroy(hmgr);
    destroy(qmgr);
    destroy(umgr);
}

static void test_match_limit1(void)
{
    var                umgr;
    var                qmgr;
    var                hmgr;
    var                pmgr;
    xce_limit_t*       limit;
    int                rc;
    xce_limit_config_t limit_config = {
        .name        = "limit1",
        .per_user    = 0,
        .per_queue   = 0,
        .per_project = 0,
        .per_host    = 0,
        .users
        = &(xce_group_config_t) { .members
                                  = { .count = 1, .data = (char*[]) { "all" } },
                                 .ex_members
                                  = { .count = 1,
                                      .data  = (char*[]) { "rshen" } } },
        .queues
        = &(xce_group_config_t) { .members = { .count = 1,
                                               .data  = (char*[]) { "all" } } },
        .hosts = NULL,
        .projects
        = &(xce_group_config_t) { .members = { .count = 1,
                                               .data  = (char*[]) { "all" } } },
        .val
        = &(xce_limit_val_t) { .resname = "mem", .percent = 1, .val = 80.0 }
    };
    char buf[1024];

    groupmgr_init(&umgr, 4, 4);
    groupmgr_init(&qmgr, 4, 4);
    groupmgr_init(&hmgr, 4, 4);
    groupmgr_init(&pmgr, 4, 4);

    rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
    TEST_ASSERT_TRUE(rc == 1);

    memset(buf, 0x0, sizeof(buf));

    rc = fmt_limit(buf, sizeof(buf) - 1, limit);
    TEST_ASSERT_TRUE(rc > 0);

    printf("%s\n", buf);

    rc = match_limit(limit, 1, "rshen", "xce", "project1");
    TEST_ASSERT_TRUE(rc == 0);

    kill_limit(limit);

    destroy(pmgr);
    destroy(hmgr);
    destroy(qmgr);
    destroy(umgr);
}

static void test_match_limit2(void)
{
    var                umgr;
    var                qmgr;
    var                hmgr;
    var                pmgr;
    xce_limit_t*       limit;
    int                rc;
    xce_limit_config_t limit_config = {
        .name        = "limit1",
        .per_user    = 0,
        .per_queue   = 0,
        .per_project = 0,
        .per_host    = 0,
        .users
        = &(xce_group_config_t) { .members
                                  = { .count = 1, .data = (char*[]) { "all" } },
                                 .ex_members
                                  = { .count = 1,
                                      .data  = (char*[]) { "rshen" } } },
        .queues   = NULL,
        .hosts    = NULL,
        .projects = NULL,
        .val
        = &(xce_limit_val_t) { .resname = "slots", .percent = 0, .val = 3.0 }
    };
    char buf[1024];

    groupmgr_init(&umgr, 4, 4);
    groupmgr_init(&qmgr, 4, 4);
    groupmgr_init(&hmgr, 4, 4);
    groupmgr_init(&pmgr, 4, 4);

    rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
    TEST_ASSERT_TRUE(rc == 1);

    memset(buf, 0x0, sizeof(buf));

    rc = fmt_limit(buf, sizeof(buf) - 1, limit);
    TEST_ASSERT_TRUE(rc > 0);

    printf("%s\n", buf);

    rc = match_limit(limit, 1, "rshen", "normal", "default");
    TEST_ASSERT_TRUE(rc == 0);

    kill_limit(limit);

    destroy(pmgr);
    destroy(hmgr);
    destroy(qmgr);
    destroy(umgr);
}

void test_limit(void)
{
    printf("\n>> limit test\n\n");

    xstring_table_init(139);
    
    RUN_TEST(test_build_consumer1);
    RUN_TEST(test_build_consumer2);
    RUN_TEST(test_build_limit_ok1);
    RUN_TEST(test_match_limit_ok1);
    RUN_TEST(test_match_limit_ok2);
    RUN_TEST(test_match_limit1);
    RUN_TEST(test_match_limit2);

    xstring_table_fini();
}