#include "framework/framework.h"

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

typedef struct {

    uint32_t conference;

    bool connected;

    uint32_t peer_count;

    bool n1_should_be_offline;

    bool coordinator_should_be_offline;

} State;

static void on_conference_invite(const Tox_Event_Conference_Invite *event, void *user_data)

{

    ToxNode *self = (ToxNode *)user_data;

    State *state = (State *)tox_node_get_script_ctx(self);

    state->conference = tox_conference_join(tox_node_get_tox(self),

                                            tox_event_conference_invite_get_friend_number(event),

                                            tox_event_conference_invite_get_cookie(event),

                                            tox_event_conference_invite_get_cookie_length(event),

                                            nullptr);

    tox_node_log(self, "Joined conference %u", state->conference);

}

static void on_conference_connected(const Tox_Event_Conference_Connected *event, void *user_data)

{

    ToxNode *self = (ToxNode *)user_data;

    State *state = (State *)tox_node_get_script_ctx(self);

    state->connected = true;

    tox_node_log(self, "Connected to conference");

}

static void node_script(ToxNode *self, void *ctx)

{

    const State *state = (const State *)ctx;

    const Tox *tox = tox_node_get_tox(self);

    Tox_Dispatch *dispatch = tox_node_get_dispatch(self);

    tox_events_callback_conference_invite(dispatch, on_conference_invite);

    tox_events_callback_conference_connected(dispatch, on_conference_connected);

    tox_node_log(self, "Waiting for self connection...");

    tox_node_wait_for_self_connected(self);

    tox_node_log(self, "Connected to DHT!");

    // Wait for all nodes to be DHT-connected

    for (int i = 0; i < 5; ++i) {

        ToxNode *node = tox_scenario_get_node(tox_node_get_scenario(self), i);

        WAIT_UNTIL(tox_node_is_self_connected(node));

    }

    tox_node_log(self, "All nodes connected to DHT!");

    // Nodes 0, 1, 3, 4 just wait to be invited and connect.

    // Coordination is handled by Node 2 (Founder/Coordinator).

    tox_node_log(self, "Waiting for conference connection...");

    WAIT_UNTIL(state->connected);

    tox_node_log(self, "Connected to conference!");

    // In this test, nodes participate in multiple phases.

    // They just stay alive until the group is fully merged.

    WAIT_UNTIL(tox_conference_peer_count(tox, state->conference, nullptr) == 5);

    tox_node_log(self, "Finished!");

}

static void coordinator_script(ToxNode *self, void *ctx)

{

    State *state = (State *)ctx;

    Tox *tox = tox_node_get_tox(self);

    Tox_Dispatch *dispatch = tox_node_get_dispatch(self);

    tox_events_callback_conference_invite(dispatch, on_conference_invite);

    tox_events_callback_conference_connected(dispatch, on_conference_connected);

    tox_node_log(self, "Waiting for self connection...");

    tox_node_wait_for_self_connected(self);

    tox_node_log(self, "Connected to DHT!");

    // Wait for all nodes to be DHT-connected

    for (int i = 0; i < 5; ++i) {

        ToxNode *node = tox_scenario_get_node(tox_node_get_scenario(self), i);

        WAIT_UNTIL(tox_node_is_self_connected(node));

    }

    tox_node_log(self, "All nodes connected to DHT!");

    // 1. Create conference

    state->conference = tox_conference_new(tox, nullptr);

    state->connected = true;

    tox_node_log(self, "Created conference %u", state->conference);

    // 2. Invite Node 1

    tox_node_log(self, "Waiting for friend 0 (Node1) to connect...");

    tox_node_wait_for_friend_connected(self, 0); // Node 1 is friend 0

    tox_node_log(self, "Friend 0 (Node1) connected! Inviting...");

    tox_conference_invite(tox, 0, state->conference, nullptr);

    const ToxNode *n1 = tox_scenario_get_node(tox_node_get_scenario(self), 1);

    const State *s1_view = (const State *)tox_node_get_peer_ctx(n1);

    WAIT_UNTIL(s1_view->connected);

    // 3. Node 1 invites Node 0

    // Wait for Node 0 to join conference

    const ToxNode *n0 = tox_scenario_get_node(tox_node_get_scenario(self), 0);

    const State *s0_view = (const State *)tox_node_get_peer_ctx(n0);

    tox_node_log(self, "Waiting for Node 0 to join conference...");

    WAIT_UNTIL(s0_view->connected);

    tox_node_log(self, "Node 0 joined!");

    // 4. Split: Node 1 goes offline

    tox_node_log(self, "Splitting group. Node 1 goes offline.");

    state->n1_should_be_offline = true;

    // Wait for Coordinator to see Node 1 is gone (Safe read via mirror)

    tox_node_log(self, "Waiting for Node 1 to be seen as gone from conference...");

    WAIT_UNTIL(tox_conference_peer_count(tox, state->conference, nullptr) == 2); // Only Coordinator and Node 0 left

    // 5. Coordinator invites Node 3

    tox_node_log(self, "Waiting for friend 1 (Node3) to connect...");

    tox_node_wait_for_friend_connected(self, 1); // Node 3 is friend 1

    tox_node_log(self, "Friend 1 (Node3) connected! Inviting...");

    tox_conference_invite(tox, 1, state->conference, nullptr);

    const ToxNode *n3 = tox_scenario_get_node(tox_node_get_scenario(self), 3);

    const State *s3_view = (const State *)tox_node_get_peer_ctx(n3);

    WAIT_UNTIL(s3_view->connected);

    // 6. Node 3 invites Node 4

    const ToxNode *n4 = tox_scenario_get_node(tox_node_get_scenario(self), 4);

    const State *s4_view = (const State *)tox_node_get_peer_ctx(n4);

    tox_node_log(self, "Waiting for Node 4 to join conference...");

    WAIT_UNTIL(s4_view->connected);

    tox_node_log(self, "Node 4 joined!");

    // 7. Coordinator goes offline, Node 1 comes back online

    tox_node_log(self, "Coordinator goes offline, Node 1 comes back online.");

    state->n1_should_be_offline = false;

    tox_node_set_offline(self, true);

    // Wait in offline mode

    for (int i = 0; i < 200; ++i) {

        tox_scenario_yield(self);

    }

    // 8. Node 1 merges groups by inviting Node 3

    // This is handled in Node 1's script after it observes n1_should_be_offline == false.

    // 9. Coordinator comes back online

    tox_node_log(self, "Coming back online.");

    tox_node_set_offline(self, false);

    // Coordinator rejoins

    // In original test: reload and invite again.

    // Here we just re-sync.

    // Wait for all nodes to be in one group

    WAIT_UNTIL(tox_conference_peer_count(tox, state->conference, nullptr) == 5);

    tox_node_log(self, "Group merged successfully!");

}

static void n1_script(ToxNode *self, void *ctx)

{

    const State *state = (const State *)ctx;

    Tox *tox = tox_node_get_tox(self);

    Tox_Dispatch *dispatch = tox_node_get_dispatch(self);

    tox_events_callback_conference_invite(dispatch, on_conference_invite);

    tox_events_callback_conference_connected(dispatch, on_conference_connected);

    tox_node_log(self, "Waiting for self connection...");

    tox_node_wait_for_self_connected(self);

    tox_node_log(self, "Connected to DHT!");

    // Wait for all nodes to be DHT-connected

    for (int i = 0; i < 5; ++i) {

        ToxNode *node = tox_scenario_get_node(tox_node_get_scenario(self), i);

        WAIT_UNTIL(tox_node_is_self_connected(node));

    }

    tox_node_log(self, "All nodes connected to DHT!");

    // Phase 1: Wait to join

    tox_node_log(self, "Waiting for conference connection...");

    WAIT_UNTIL(state->connected);

    tox_node_log(self, "Connected to conference!");

    // Phase 2: Invite Node 0

    tox_node_log(self, "Waiting for friend 0 (Node0) to connect...");

    tox_node_wait_for_friend_connected(self, 0); // Node 0 is friend 0

    tox_node_log(self, "Friend 0 (Node0) connected! Inviting...");

    tox_conference_invite(tox, 0, state->conference, nullptr);

    // Phase 3: Split (we will be set offline by Coordinator)

    // Observe coordinator's request for our offline status

    const ToxNode *coordinator = tox_scenario_get_node(tox_node_get_scenario(self), 2);

    const State *coord_view = (const State *)tox_node_get_peer_ctx(coordinator);

    WAIT_UNTIL(coord_view->n1_should_be_offline);

    tox_node_log(self, "Going offline as requested by coordinator.");

    tox_node_set_offline(self, true);

    WAIT_UNTIL(!coord_view->n1_should_be_offline);

    tox_node_log(self, "Coming back online as requested by coordinator.");

    tox_node_set_offline(self, false);

    // Phase 4: Merge groups

    // Node 3 is friend 2 for Node 1

    tox_node_log(self, "Waiting for friend 2 (Node3) to connect...");

    tox_node_wait_for_friend_connected(self, 2);

    tox_node_log(self, "Friend 2 (Node3) connected! Inviting to merge...");

    tox_node_log(self, "Inviting Node 3 to merge groups.");

    tox_conference_invite(tox, 2, state->conference, nullptr);

    WAIT_UNTIL(tox_conference_peer_count(tox, state->conference, nullptr) == 5);

    tox_node_log(self, "Finished!");

}

static void n3_script(ToxNode *self, void *ctx)

{

    const State *state = (const State *)ctx;

    Tox *tox = tox_node_get_tox(self);

    Tox_Dispatch *dispatch = tox_node_get_dispatch(self);

    tox_events_callback_conference_invite(dispatch, on_conference_invite);

    tox_events_callback_conference_connected(dispatch, on_conference_connected);

    tox_node_log(self, "Waiting for self connection...");

    tox_node_wait_for_self_connected(self);

    tox_node_log(self, "Connected to DHT!");

    // Wait for all nodes to be DHT-connected

    for (int i = 0; i < 5; ++i) {

        ToxNode *node = tox_scenario_get_node(tox_node_get_scenario(self), i);

        WAIT_UNTIL(tox_node_is_self_connected(node));

    }

    tox_node_log(self, "All nodes connected to DHT!");

    // Phase 2: Wait to join

    tox_node_log(self, "Waiting for conference connection...");

    WAIT_UNTIL(state->connected);

    tox_node_log(self, "Connected to conference!");

    // Phase 3: Invite Node 4

    // Node 3 invites Node 4 when Coordinator is ready.

    // We can just wait for Node 1 to go offline, which signals the split.

    ToxNode *n1 = tox_scenario_get_node(tox_node_get_scenario(self), 1);

    WAIT_UNTIL(tox_node_is_offline(n1));

    tox_node_log(self, "Waiting for friend 1 (Node4) to connect...");

    tox_node_wait_for_friend_connected(self, 1); // Node 4 is friend 1

    tox_node_log(self, "Friend 1 (Node4) connected! Inviting...");

    tox_conference_invite(tox, 1, state->conference, nullptr);

    WAIT_UNTIL(tox_conference_peer_count(tox, state->conference, nullptr) == 5);

    tox_node_log(self, "Finished!");

}

int main(int argc, char *argv[])

{

    ToxScenario *s = tox_scenario_new(argc, argv, 300000);

    State states[5] = {0};

    ToxNode *nodes[5];

    nodes[0] = tox_scenario_add_node(s, "Node0", node_script, &states[0], sizeof(State));

    nodes[1] = tox_scenario_add_node(s, "Node1", n1_script, &states[1], sizeof(State));

    nodes[2] = tox_scenario_add_node(s, "Coordinator", coordinator_script, &states[2], sizeof(State));

    nodes[3] = tox_scenario_add_node(s, "Node3", n3_script, &states[3], sizeof(State));

    nodes[4] = tox_scenario_add_node(s, "Node4", node_script, &states[4], sizeof(State));

    // Topology: 0-1-2-3-4

    tox_node_friend_add(nodes[0], nodes[1]);

    tox_node_friend_add(nodes[1], nodes[0]);

    tox_node_friend_add(nodes[1], nodes[2]);

    tox_node_friend_add(nodes[2], nodes[1]);

    tox_node_friend_add(nodes[2], nodes[3]);

    tox_node_friend_add(nodes[3], nodes[2]);

    tox_node_friend_add(nodes[3], nodes[4]);

    tox_node_friend_add(nodes[4], nodes[3]);

    // Merge connection: 1-3

    tox_node_friend_add(nodes[1], nodes[3]);

    tox_node_friend_add(nodes[3], nodes[1]);

    for (int i = 0; i < 5; ++i) {

        for (int j = 0; j < 5; ++j) {

            if (i != j) {

                tox_node_bootstrap(nodes[i], nodes[j]);

            }

        }

    }

    ToxScenarioStatus res = tox_scenario_run(s);

    if (res != TOX_SCENARIO_DONE) {

        tox_scenario_log(s, "Test failed with status %u", res);

        return 1;

    }

    tox_scenario_free(s);

    return 0;

}