#include "prx/libSceProprietaryVoiceChatHelperPrx/include/Api.hpp"
#include "prx/libc/include/general/VabiMacros.hpp"

#include <cstdio>
#include <cstdlib>
#include <stdexcept>
#include <string>

static void Require(bool value, const char* what) {
    if (value) return;
    std::printf("ProprietaryVoiceChatHelper: %s\n", what);
    std::abort();
}

template <typename TError, typename TCall>
static bool Throws(TCall call) {
    try {
        call();
    } catch (const TError&) {
        return true;
    }
    return false;
}

template <typename TError, typename TCall>
static bool ThrowsMessage(TCall call, const char* message) {
    try {
        call();
    } catch (const TError& error) {
        return std::string(error.what()).find(message) != std::string::npos;
    }
    return false;
}

int main() {
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperSetVoiceChatState(); }),
            "setting the state before initialization did not throw");
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperGetVoiceChatUsageState(); }),
            "reading the usage state before initialization did not throw");
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperGetVoiceChat(); }),
            "getting voice chat before initialization did not throw");
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperTerminate(); }),
            "terminating before initialization did not throw");

    Require(sceProprietaryVoiceChatHelperInitialize() == 0, "initialization failed");
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperInitialize(); }),
            "initializing twice did not throw");
    Require(sceProprietaryVoiceChatHelperSetVoiceChatState() == 0, "setting the state failed");
    Require(Throws<std::runtime_error>([] { sceProprietaryVoiceChatHelperGetVoiceChatUsageState(); }),
            "reading the unknown usage state did not throw");
    Require(Throws<std::runtime_error>([] { sceProprietaryVoiceChatHelperGetVoiceChat(); }),
            "calling unknown voice chat export did not throw");
    Require(sceProprietaryVoiceChatHelperTerminate() == 0, "termination failed");

    Require(ThrowsMessage<std::logic_error>([] { sceProprietaryVoiceChatHelperSetVoiceChatState(); },
                                            "library not initialized"),
            "setting the state after termination did not throw");
    Require(ThrowsMessage<std::logic_error>([] { sceProprietaryVoiceChatHelperGetVoiceChat(); },
                                            "library not initialized"),
            "getting voice chat after termination did not throw");
    Require(ThrowsMessage<std::logic_error>([] { sceProprietaryVoiceChatHelperGetVoiceChatUsageState(); },
                                            "library not initialized"),
            "reading the usage state after termination did not throw");
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperTerminate(); }),
            "terminating a second time did not throw");

    Require(sceProprietaryVoiceChatHelperInitialize() == 0, "initialization after termination failed");
    Require(sceProprietaryVoiceChatHelperTerminate() == 0, "termination after reinitialization failed");
    Require(Throws<std::logic_error>([] { sceProprietaryVoiceChatHelperTerminate(); }),
            "terminating a second time did not throw");

    std::puts("ProprietaryVoiceChatHelper tests passed");
    return 0;
}