//
// Created by WolverinDEV on 24/10/2020.
//

#include "./lib.h"
#include "./imports.h"
#include "../client/SpeakingClient.h"
#include "../client/voice/VoiceClient.h"
#include <Definitions.h>

using namespace ts;
using namespace ts::server;
using namespace ts::rtc;

struct LibCallbackData {
    ClientId client_id;
    std::weak_ptr<SpeakingClient> weak_ref;
};

#define log(...) \
switch(level) { \
    case 0: \
        logTrace(__VA_ARGS__); \
        break; \
    case 1: \
        debugMessage(__VA_ARGS__); \
        break; \
    case 2: \
        logMessage(__VA_ARGS__); \
        break; \
    case 3: \
        logWarning(__VA_ARGS__); \
        break; \
    case 4: \
        logError(__VA_ARGS__); \
        break; \
    case 5: \
        logCritical(__VA_ARGS__); \
        break; \
    default: \
        debugMessage(__VA_ARGS__); \
        break; \
}

void librtc_callback_log(uint8_t level, const void* callback_data_ptr, const char* message_ptr, uint32_t length) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;
    std::string_view message{message_ptr, length};

    if(callback_data) {
        auto source_client = callback_data->weak_ref.lock();
        if(!source_client) { return; }

        log(source_client->getServerId(), "{} [WebRTC] {}", CLIENT_STR_LOG_PREFIX_(source_client), message);
    } else {
        log(LOG_GENERAL, "{}", message);
    }
}

#undef log

void librtc_callback_free_client_data(const void* data) {
    delete (LibCallbackData*) data;
}

uint32_t librtc_callback_rtc_configure(const void* callback_data_ptr, void* configure_ptr) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;

    auto target_client = callback_data->weak_ref.lock();
    if(!target_client) { return 2; }

    RtpClientConfigureOptions options{};
    memset(&options, 0, sizeof(options));

    options.ice_tcp = config::web::tcp_enabled;
    options.ice_udp = config::web::udp_enabled;
    options.ice_upnp = config::web::enable_upnp;
    options.max_port = config::web::webrtc_port_min;
    options.max_port = config::web::webrtc_port_max;

    std::string stun_host{config::web::stun_host};
    options.stun_host = stun_host.c_str();
    options.stun_port = config::web::stun_port;
    if(!config::web::stun_enabled) {
        options.stun_port = 0;
        options.stun_host = nullptr;
    }

    auto result = librtc_rtc_configure(configure_ptr, &options, sizeof(options));
    if(result) {
        logError(target_client->getServerId(), "{} Failed to configure RTC connection: {}", CLIENT_STR_LOG_PREFIX_(target_client), result);
        librtc_free_str(result);
        return 1;
    }
    return 0;
}

void librtc_callback_client_stream_assignment(const void* callback_data_ptr, uint32_t stream_id, uint8_t media_type, const void* source_data_ptr) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;
    auto source_data = (LibCallbackData*) source_data_ptr;

    auto target_client = callback_data->weak_ref.lock();
    if(!target_client) { return; }

    if(source_data) {
        auto source_client = source_data->weak_ref.lock();
        if(!source_client) { return; }

        ts::command_builder notify{"notifyrtcstreamassignment"};
        notify.put_unchecked(0, "streamid", stream_id);
        notify.put_unchecked(0, "media", media_type);
        notify.put_unchecked(0, "sclid", source_client->getClientId());
        notify.put_unchecked(0, "scluid", source_client->getUid());
        notify.put_unchecked(0, "scldbid", source_client->getClientDatabaseId());
        notify.put_unchecked(0, "sclname", source_client->getDisplayName());
        target_client->sendCommand(notify);
    } else {
        ts::command_builder notify{"notifyrtcstreamassignment"};
        notify.put_unchecked(0, "streamid", stream_id);
        notify.put_unchecked(0, "sclid", 0);
        target_client->sendCommand(notify);
    }
}

void librtc_callback_client_offer_generated(const void* callback_data_ptr, const char* offer, size_t offer_length) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;
    auto target_client = callback_data->weak_ref.lock();
    if(!target_client) { return; }

    ts::command_builder notify{"notifyrtcsessiondescription"};
    notify.put_unchecked(0, "mode", "offer");
    notify.put_unchecked(0, "sdp", std::string_view{offer, offer_length});
    target_client->sendCommand(notify);
    /* don't blame the client if we require him to do anything */
    target_client->rtc_session_pending_describe = true;
}

void librtc_callback_client_audio_start(const void* callback_data_ptr, uint32_t stream_id, const void* source_data_ptr) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;
    auto source_data = (LibCallbackData*) source_data_ptr;

    auto target_client = callback_data->weak_ref.lock();
    if(!target_client) { return; }

    auto source_client = source_data->weak_ref.lock();
    if(!source_client) { return; }

    ts::command_builder notify{"notifyrtcstreamstate"};
    notify.put_unchecked(0, "streamid", stream_id);
    notify.put_unchecked(0, "sclid", source_client->getClientId());
    notify.put_unchecked(0, "scluid", source_client->getUid());
    notify.put_unchecked(0, "scldbid", source_client->getClientDatabaseId());
    notify.put_unchecked(0, "sclname", source_client->getDisplayName());
    notify.put_unchecked(0, "state", "1");
    target_client->sendCommand(notify);
}

void librtc_callback_client_audio_stop(const void* callback_data_ptr, uint32_t stream_id, const void* source_data_ptr) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;
    auto source_data = (LibCallbackData*) source_data_ptr;

    auto target_client = callback_data->weak_ref.lock();
    if(!target_client) { return; }

    auto source_client = source_data->weak_ref.lock();
    if(!source_client) { return; }

    ts::command_builder notify{"notifyrtcstreamstate"};
    notify.put_unchecked(0, "streamid", stream_id);
    notify.put_unchecked(0, "sclid", source_client->getClientId());
    notify.put_unchecked(0, "state", "0");
    target_client->sendCommand(notify);
}

void librtc_callback_client_audio_sender_data(const void* callback_data_ptr, const void* source_data_ptr, uint8_t mode, uint16_t seq_no, uint8_t codec, const void* data, uint32_t length) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;
    auto source_data = (LibCallbackData*) source_data_ptr;

    /* Target client must be a voice client. The web client does not uses the native audio client */
    auto target_client = std::dynamic_pointer_cast<VoiceClient>(callback_data->weak_ref.lock());
    if(!target_client) { return; }

    auto source_client = source_data->weak_ref.lock();
    if(!source_client) { return; }

    if(mode == 0) {
        if(!target_client->shouldReceiveVoice(source_client)) {
            return;
        }

        target_client->send_voice(source_client, seq_no, codec, data, length);
    } else if(mode == 1) {
        if(!target_client->shouldReceiveVoiceWhisper(source_client)) {
            return;
        }

        target_client->send_voice_whisper(source_client, seq_no, codec, data, length);
    } else {
        /* we've received audio with an invalid mode.... */
    }
}

void librtc_client_whisper_session_reset(const void* callback_data_ptr) {
    auto callback_data = (LibCallbackData*) callback_data_ptr;

    auto client = std::dynamic_pointer_cast<SpeakingClient>(callback_data->weak_ref.lock());
    if(!client) { return; }

    client->whisper_handler().handle_session_reset();

    ts::command_builder notify{"notifywhispersessionreset"};
    client->sendCommand(notify);
}

static NativeCallbacks native_callbacks{
        .version = 4,

        .log = librtc_callback_log,
        .free_client_data = librtc_callback_free_client_data,

        .rtc_configure = librtc_callback_rtc_configure,

        .client_stream_assignment = librtc_callback_client_stream_assignment,
        .client_offer_generated = librtc_callback_client_offer_generated,

        .client_stream_start = librtc_callback_client_audio_start,
        .client_stream_stop = librtc_callback_client_audio_stop,

        .client_audio_sender_data = librtc_callback_client_audio_sender_data,
        .client_whisper_session_reset = librtc_client_whisper_session_reset
};

std::string_view rtc::version() {
    return std::string_view{librtc_version()};
}

bool rtc::initialize(std::string &error) {
    auto error_ptr = librtc_init(&native_callbacks, sizeof native_callbacks);
    if(!error_ptr) { return true; }

    error = std::string{error_ptr};
    librtc_free_str(error_ptr);
    return false;
}

Server::Server() {
    this->server_ptr = librtc_create_server();
}

Server::~Server() {
    librtc_destroy_server(this->server_ptr);
}

RTCClientId Server::create_client(const std::shared_ptr<server::SpeakingClient> &client) {
    auto data = new LibCallbackData{
            .client_id = client->getClientId(),
            .weak_ref = client
    };

    return librtc_create_client(this->server_ptr, data);
}

bool Server::initialize_rtc_connection(std::string &error, RTCClientId client_id) {
    auto error_ptr = librtc_initialize_rtc_connection(this->server_ptr, client_id);
    if(!error_ptr) { return true; }

    error = std::string{error_ptr};
    librtc_free_str(error_ptr);
    return false;
}

bool Server::initialize_native_connection(std::string &error, RTCClientId client_id) {
    auto error_ptr = librtc_initialize_native_connection(this->server_ptr, client_id);
    if(!error_ptr) { return true; }

    error = std::string{error_ptr};
    librtc_free_str(error_ptr);
    return false;
}

void Server::destroy_client(RTCClientId client_id) {
    librtc_destroy_client(this->server_ptr, client_id);
}

void Server::reset_rtp_session(RTCClientId client_id) {
    librtc_reset_rtp_session(this->server_ptr, client_id);
}

bool Server::apply_remote_description(std::string &error, RTCClientId client_id, uint32_t mode, const std::string &description) {
    auto error_ptr = librtc_apply_remote_description(this->server_ptr, client_id, mode, description.c_str());
    if(!error_ptr) { return true; }

    error = std::string{error_ptr};
    librtc_free_str(error_ptr);
    return false;
}

bool Server::generate_local_description(RTCClientId client, std::string &result) {
    char* description_ptr;
    auto error_ptr = librtc_generate_local_description(this->server_ptr, client, &description_ptr);
    if(error_ptr) {
        result = std::string{error_ptr};
        librtc_free_str(error_ptr);
        return false;
    } else {
        result = std::string{description_ptr};
        librtc_free_str(description_ptr);
        return true;
    }
}

bool Server::add_ice_candidate(std::string &error, RTCClientId client_id, uint32_t media_line, const std::string &description) {
    auto error_ptr = librtc_add_ice_candidate(this->server_ptr, client_id, media_line, description.length() == 0 ? nullptr : description.c_str());
    if(!error_ptr) { return true; }

    error = std::string{error_ptr};
    librtc_free_str(error_ptr);
    return false;
}

void Server::ice_candidates_finished(RTCClientId) {
    /* Nothing really to do here */
}

uint32_t Server::create_channel() {
    return librtc_create_channel(this->server_ptr);
}

ChannelAssignResult Server::assign_channel(uint32_t client_id, uint32_t channel_id) {
    auto result = librtc_assign_channel(this->server_ptr, client_id, channel_id);
    switch(result) {
        case 0x00: return ChannelAssignResult::Success;
        case 0x01: return ChannelAssignResult::ClientUnknown;
        case 0x02: return ChannelAssignResult::TargetChannelUnknown;
        default: return ChannelAssignResult::UnknownError;
    }
}

BroadcastStartResult Server::start_broadcast(uint32_t client_id, uint8_t btype, uint32_t track_id) {
    auto result = librtc_client_broadcast(this->server_ptr, client_id, btype, track_id);
    switch(result) {
        case 0x00: return BroadcastStartResult::Success;
        case 0x01: return BroadcastStartResult::InvalidClient;
        case 0x02: return BroadcastStartResult::ClientHasNoChannel;
        case 0x03: return BroadcastStartResult::InvalidBroadcastType;
        case 0x04: return BroadcastStartResult::InvalidStreamId;
        default: return BroadcastStartResult::UnknownError;
    }
}

std::optional<NativeAudioSourceSupplier> Server::create_audio_source_supplier_sender(uint32_t client_id, uint32_t stream_id) {
    auto result = librtc_create_audio_source_supplier(this->server_ptr, client_id, stream_id);
    if(!result) { return std::nullopt; }

    return std::make_optional<NativeAudioSourceSupplier>(result);
}

void Server::destroy_channel(uint32_t channel_id) {
    librtc_destroy_channel(this->server_ptr, channel_id);
}

bool Server::configure_whisper_session(std::string &error, RTCClientId client_id, uint32_t source_stream_id, RTCClientId *client_ids, size_t client_id_count) {
    auto error_ptr = librtc_whisper_configure(this->server_ptr, client_id, source_stream_id, client_ids, client_id_count);
    if(!error_ptr) { return true; }

    error = std::string{error_ptr};
    librtc_free_str(error_ptr);
    return false;
}

void Server::reset_whisper_session(RTCClientId client_id) {
    librtc_whisper_reset(this->server_ptr, client_id);
}

NativeAudioSourceSupplier::NativeAudioSourceSupplier(void *ptr) : sender_ptr{ptr} {}
NativeAudioSourceSupplier::NativeAudioSourceSupplier(NativeAudioSourceSupplier &&other) noexcept : sender_ptr{other.sender_ptr} {
    other.sender_ptr = nullptr;
}
NativeAudioSourceSupplier::~NativeAudioSourceSupplier() noexcept {
    if(this->sender_ptr) {
        librtc_destroy_audio_source_supplier(this->sender_ptr);
    }
}

void NativeAudioSourceSupplier::send_audio(uint16_t seq_no, bool marked, uint32_t timestamp, uint8_t codec, const std::string_view &data) {
    if(this->sender_ptr) {
        librtc_audio_source_supply(this->sender_ptr, seq_no, marked, timestamp, codec, data.empty() ? nullptr : data.data(), data.length());
    }
}