#include "framework/framework.h"

#include "../../toxav/toxav.h"

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define NUM_BOBS 3

typedef struct {

    bool incoming;

    uint32_t state;

} CallState;

static void on_call(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)

{

    ToxNode *self = (ToxNode *)user_data;

    CallState *states = (CallState *)tox_node_get_script_ctx(self);

    tox_node_log(self, "Received call from friend %u", friend_number);

    states[friend_number].incoming = true;

}

static void on_call_state(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)

{

    ToxNode *self = (ToxNode *)user_data;

    CallState *states = (CallState *)tox_node_get_script_ctx(self);

    tox_node_log(self, "Call state for friend %u changed to %u", friend_number, state);

    states[friend_number].state = state;

}

static void on_audio_receive(ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,

                             uint8_t channels, uint32_t sampling_rate, void *user_data)

{

}

static void on_video_receive(ToxAV *av, uint32_t friend_number, uint16_t width, uint16_t height,

                             uint8_t const *y, uint8_t const *u, uint8_t const *v,

                             int32_t ystride, int32_t ustride, int32_t vstride, void *user_data)

{

}

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

{

    CallState *states = (CallState *)ctx;

    Tox *tox = tox_node_get_tox(self);

    Toxav_Err_New av_err;

    ToxAV *av = toxav_new(tox, &av_err);

    ck_assert(av_err == TOXAV_ERR_NEW_OK);

    toxav_callback_call(av, on_call, self);

    toxav_callback_call_state(av, on_call_state, self);

    toxav_callback_audio_receive_frame(av, on_audio_receive, self);

    toxav_callback_video_receive_frame(av, on_video_receive, self);

    WAIT_UNTIL(tox_node_is_self_connected(self));

    for (uint32_t i = 0; i < NUM_BOBS; i++) {

        WAIT_UNTIL(tox_node_is_friend_connected(self, i));

    }

    tox_node_log(self, "All Bobs connected. Calling them...");

    for (uint32_t i = 0; i < NUM_BOBS; i++) {

        Toxav_Err_Call call_err;

        toxav_call(av, i, 48, 3000, &call_err);

        ck_assert(call_err == TOXAV_ERR_CALL_OK);

    }

    int16_t pcm[960] = {0};

    uint8_t *video_y = (uint8_t *)calloc(800 * 600, sizeof(uint8_t));

    uint8_t *video_u = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));

    uint8_t *video_v = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));

    // Send a few frames to verify flow

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

        toxav_iterate(av);

        for (uint32_t j = 0; j < NUM_BOBS; j++) {

            if (states[j].state & TOXAV_FRIEND_CALL_STATE_SENDING_A) {

                toxav_audio_send_frame(av, j, pcm, 960, 1, 48000, nullptr);

            }

            if (states[j].state & TOXAV_FRIEND_CALL_STATE_SENDING_V) {

                toxav_video_send_frame(av, j, 800, 600, video_y, video_u, video_v, nullptr);

            }

        }

        tox_scenario_yield(self);

    }

    tox_node_log(self, "Hanging up all calls...");

    for (uint32_t i = 0; i < NUM_BOBS; i++) {

        toxav_call_control(av, i, TOXAV_CALL_CONTROL_CANCEL, nullptr);

    }

    // Give it a few ticks to send hangup packets

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

        toxav_iterate(av);

        tox_scenario_yield(self);

    }

    free(video_y);

    free(video_u);

    free(video_v);

    toxav_kill(av);

}

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

{

    CallState *states = (CallState *)ctx;

    Tox *tox = tox_node_get_tox(self);

    Toxav_Err_New av_err;

    ToxAV *av = toxav_new(tox, &av_err);

    ck_assert(av_err == TOXAV_ERR_NEW_OK);

    toxav_callback_call(av, on_call, self);

    toxav_callback_call_state(av, on_call_state, self);

    toxav_callback_audio_receive_frame(av, on_audio_receive, self);

    toxav_callback_video_receive_frame(av, on_video_receive, self);

    WAIT_UNTIL(tox_node_is_self_connected(self));

    WAIT_UNTIL(tox_node_is_friend_connected(self, 0));

    while (!states[0].incoming && tox_scenario_is_running(self)) {

        toxav_iterate(av);

        tox_scenario_yield(self);

    }

    tox_node_log(self, "Answering call...");

    Toxav_Err_Answer answer_err;

    toxav_answer(av, 0, 8, 500, &answer_err);

    ck_assert(answer_err == TOXAV_ERR_ANSWER_OK);

    int16_t pcm[960] = {0};

    uint8_t *video_y = (uint8_t *)calloc(800 * 600, sizeof(uint8_t));

    uint8_t *video_u = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));

    uint8_t *video_v = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));

    while (!(states[0].state & TOXAV_FRIEND_CALL_STATE_FINISHED) && tox_scenario_is_running(self)) {

        toxav_iterate(av);

        if (states[0].state & TOXAV_FRIEND_CALL_STATE_SENDING_A) {

            toxav_audio_send_frame(av, 0, pcm, 960, 1, 48000, nullptr);

        }

        if (states[0].state & TOXAV_FRIEND_CALL_STATE_SENDING_V) {

            toxav_video_send_frame(av, 0, 800, 600, video_y, video_u, video_v, nullptr);

        }

        tox_scenario_yield(self);

    }

    tox_node_log(self, "Call finished.");

    free(video_y);

    free(video_u);

    free(video_v);

    toxav_kill(av);

}

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

{

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

    CallState alice_states[NUM_BOBS] = {0};

    Tox_Options *opts = tox_options_new(nullptr);

    tox_options_set_ipv6_enabled(opts, false);

    tox_options_set_local_discovery_enabled(opts, false);

    ToxNode *alice = tox_scenario_add_node_ex(s, "Alice", alice_script, alice_states, sizeof(alice_states), opts);

    ToxNode *bobs[NUM_BOBS];

    CallState bob_states[NUM_BOBS];

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

        char name[32];

        snprintf(name, sizeof(name), "Bob-%d", i);

        bob_states[i] = (CallState) {

            0

        };

        bobs[i] = tox_scenario_add_node_ex(s, name, bob_script, &bob_states[i], sizeof(CallState), opts);

        tox_node_bootstrap(bobs[i], alice);

        tox_node_friend_add(alice, bobs[i]);

        tox_node_friend_add(bobs[i], alice);

    }

    tox_options_free(opts);

    ToxScenarioStatus res = tox_scenario_run(s);

    tox_scenario_free(s);

    return (res == TOX_SCENARIO_DONE) ? 0 : 1;

}