#include "framework/framework.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define GROUP_NAME "The Test Chamber"
#define GROUP_NAME_LEN (sizeof(GROUP_NAME) - 1)
#define TOPIC "They're waiting for you Gordon..."
#define TOPIC_LEN (sizeof(TOPIC) - 1)
#define NEW_PRIV_STATE TOX_GROUP_PRIVACY_STATE_PRIVATE
#define PASSWORD "password123"
#define PASS_LEN (sizeof(PASSWORD) - 1)
#define PEER_LIMIT 69
#define PEER0_NICK "Mike"
#define PEER0_NICK_LEN (sizeof(PEER0_NICK) - 1)
#define NEW_USER_STATUS TOX_USER_STATUS_BUSY

typedef struct {
    bool peer_joined;
} State;

static void on_group_invite(const Tox_Event_Group_Invite *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    uint32_t friend_number = tox_event_group_invite_get_friend_number(event);
    const uint8_t *invite_data = tox_event_group_invite_get_invite_data(event);
    size_t length = tox_event_group_invite_get_invite_data_length(event);

    tox_group_invite_accept(tox_node_get_tox(self), friend_number, invite_data, length, (const uint8_t *)"Bob", 3, nullptr, 0, nullptr);
}

static void on_group_peer_join(const Tox_Event_Group_Peer_Join *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    State *state = (State *)tox_node_get_script_ctx(self);
    state->peer_joined = true;
}

static void check_founder_state(ToxNode *self, uint32_t group_number, const uint8_t *expected_chat_id, const uint8_t *expected_self_pk)
{
    Tox *tox = tox_node_get_tox(self);
    Tox_Err_Group_State_Query query_err;

    // Group state
    ck_assert(tox_group_get_privacy_state(tox, group_number, &query_err) == NEW_PRIV_STATE);
    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);

    uint8_t password[TOX_GROUP_MAX_PASSWORD_SIZE];
    size_t pass_len = tox_group_get_password_size(tox, group_number, &query_err);
    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
    tox_group_get_password(tox, group_number, password, &query_err);
    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
    ck_assert(pass_len == PASS_LEN && memcmp(password, PASSWORD, pass_len) == 0);

    uint8_t gname[TOX_GROUP_MAX_GROUP_NAME_LENGTH];
    size_t gname_len = tox_group_get_name_size(tox, group_number, &query_err);
    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
    tox_group_get_name(tox, group_number, gname, &query_err);
    ck_assert(gname_len == GROUP_NAME_LEN && memcmp(gname, GROUP_NAME, gname_len) == 0);

    ck_assert(tox_group_get_peer_limit(tox, group_number, nullptr) == PEER_LIMIT);
    ck_assert(tox_group_get_topic_lock(tox, group_number, nullptr) == TOX_GROUP_TOPIC_LOCK_DISABLED);

    uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
    tox_group_get_chat_id(tox, group_number, chat_id, nullptr);
    ck_assert(memcmp(chat_id, expected_chat_id, TOX_GROUP_CHAT_ID_SIZE) == 0);

    // Self state
    Tox_Err_Group_Self_Query sq_err;
    uint8_t self_name[TOX_MAX_NAME_LENGTH];
    size_t self_len = tox_group_self_get_name_size(tox, group_number, &sq_err);
    tox_group_self_get_name(tox, group_number, self_name, nullptr);
    ck_assert(self_len == PEER0_NICK_LEN && memcmp(self_name, PEER0_NICK, self_len) == 0);

    ck_assert(tox_group_self_get_status(tox, group_number, nullptr) == NEW_USER_STATUS);
    ck_assert(tox_group_self_get_role(tox, group_number, nullptr) == TOX_GROUP_ROLE_FOUNDER);

    uint8_t self_pk[TOX_GROUP_PEER_PUBLIC_KEY_SIZE];
    tox_group_self_get_public_key(tox, group_number, self_pk, nullptr);
    ck_assert(memcmp(self_pk, expected_self_pk, TOX_GROUP_PEER_PUBLIC_KEY_SIZE) == 0);
}

static void founder_script(ToxNode *self, void *ctx)
{
    const State *state = (const State *)ctx;
    Tox *tox = tox_node_get_tox(self);
    tox_events_callback_group_peer_join(tox_node_get_dispatch(self), on_group_peer_join);

    tox_node_wait_for_self_connected(self);
    tox_node_wait_for_friend_connected(self, 0);

    Tox_Err_Group_New err_new;
    uint32_t group_number = tox_group_new(tox, TOX_GROUP_PRIVACY_STATE_PRIVATE, (const uint8_t *)GROUP_NAME, GROUP_NAME_LEN, (const uint8_t *)"test", 4, &err_new);
    ck_assert(err_new == TOX_ERR_GROUP_NEW_OK);

    uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
    tox_group_get_chat_id(tox, group_number, chat_id, nullptr);

    uint8_t founder_pk[TOX_GROUP_PEER_PUBLIC_KEY_SIZE];
    tox_group_self_get_public_key(tox, group_number, founder_pk, nullptr);

    tox_group_invite_friend(tox, group_number, 0, nullptr);
    WAIT_UNTIL(state->peer_joined);

    tox_node_log(self, "Bob joined. Changing group state...");
    tox_group_set_topic(tox, group_number, (const uint8_t *)TOPIC, TOPIC_LEN, nullptr);
    tox_group_set_topic_lock(tox, group_number, TOX_GROUP_TOPIC_LOCK_DISABLED, nullptr);
    tox_group_set_privacy_state(tox, group_number, NEW_PRIV_STATE, nullptr);
    tox_group_set_password(tox, group_number, (const uint8_t *)PASSWORD, PASS_LEN, nullptr);
    tox_group_set_peer_limit(tox, group_number, PEER_LIMIT, nullptr);
    tox_group_self_set_name(tox, group_number, (const uint8_t *)PEER0_NICK, PEER0_NICK_LEN, nullptr);
    tox_group_self_set_status(tox, group_number, NEW_USER_STATUS, nullptr);

    tox_scenario_yield(self);

    tox_node_log(self, "Saving and reloading...");
    tox_node_reload(self);
    tox_node_log(self, "Reloaded.");

    tox_node_wait_for_self_connected(self);
    check_founder_state(self, group_number, chat_id, founder_pk);
    tox_node_log(self, "State verified after reload.");
}

static void bob_script(ToxNode *self, void *ctx)
{
    tox_events_callback_group_invite(tox_node_get_dispatch(self), on_group_invite);
    tox_node_wait_for_self_connected(self);
    tox_node_wait_for_friend_connected(self, 0);

    ToxNode *founder = tox_scenario_get_node(tox_node_get_scenario(self), 0);
    tox_node_log(self, "Waiting for founder to finish...");
    WAIT_UNTIL(tox_node_is_finished(founder));
    tox_node_log(self, "Founder finished, Bob exiting.");
}

int main(int argc, char *argv[])
{
    ToxScenario *s = tox_scenario_new(argc, argv, 60000);
    State states[2] = {{0}};

    Tox_Options *opts = tox_options_new(nullptr);
    tox_options_set_experimental_groups_persistence(opts, true);
    tox_options_set_ipv6_enabled(opts, false);
    tox_options_set_local_discovery_enabled(opts, false);

    ToxNode *alice = tox_scenario_add_node_ex(s, "Alice", founder_script, &states[0], sizeof(State), opts);
    ToxNode *bob = tox_scenario_add_node(s, "Bob", bob_script, &states[1], sizeof(State));
    tox_options_free(opts);

    tox_node_bootstrap(bob, alice);
    tox_node_friend_add(alice, bob);
    tox_node_friend_add(bob, alice);

    ToxScenarioStatus res = tox_scenario_run(s);
    if (res != TOX_SCENARIO_DONE) {
        return 1;
    }

    tox_scenario_free(s);
    return 0;
}

#undef PASSWORD
#undef PASS_LEN
#undef PEER_LIMIT
#undef GROUP_NAME
#undef GROUP_NAME_LEN
#undef TOPIC
#undef TOPIC_LEN
#undef PEER0_NICK
#undef PEER0_NICK_LEN