#include <chrono>
#include <thread>
#include <string>
#include <iostream>

#include <nakama-cpp/Nakama.h>
#include <nakama-cpp/log/NLogger.h>
#include <nakama-cpp/realtime/NRtDefaultClientListener.h>

const std::string myUserName = "myUserName1";

auto params = Nakama::NClientParameters{
        .serverKey = "defaultkey",
        .host = "127.0.0.1",
        .port = 7350
    };

auto client = Nakama::createDefaultClient( params );
Nakama::NRtClientPtr rtClient = nullptr;
Nakama::NSessionPtr m_session = nullptr;
uint stateMachine = 0;  // 0 - still not connected
                        // 1 - connection in progress
                        // 2 - connected

void onAuthSucceeded(Nakama::NSessionPtr session)
{
    m_session = session;

    if ( m_session->getUsername() != myUserName ) {
        std::cout << "Wrong user name";
    }
    else if ( m_session->getVariable("test") != "value" ) {
        std::cout << "Wrong value";
    }
    else {
        std::cout << "Login succeeded. user id: " << m_session->getUserId().c_str() << std::endl;
    }

    auto vars = m_session->getVariables();
    for(const auto& elem : vars)
    {
        std::cout << elem.first << " " << elem.second << std::endl;
    }

    std::cout << m_session->isRefreshExpired() << std::endl
        << m_session->isCreated() << std::endl
        << m_session->isExpired() << std::endl
        << "ok" << std::endl;

    auto successCallback = [](const Nakama::NAccount& account)
    {
        std::cout << "user id     : " << account.user.id << std::endl;
        std::cout << "username    : " << account.user.username << std::endl;
        std::cout << "wallet      : " << account.wallet << std::endl;
        std::cout << "disableTime : " << account.disableTime << std::endl;

        if ( account.verifyTime == 0 ) {
            std::cout << "account still not verified" << std::endl;
        }

        rtClient = client->createRtClient();
        rtClient->setHeartbeatIntervalMs(500);
    };

    auto errorCallback = [](const Nakama::NError& error)
    {
        std::cout << "Error[getAccount]: " << error.message << std::endl;
    };

    client->getAccount(m_session, successCallback, errorCallback);
}

int main( int argc, char ** argv )
{
    auto vars = Nakama::NStringMap{ { "test","value" } };

    auto clientErrorCallback = [](const Nakama::NError& error)
    {
        std::cout << "Error[client]: " << error.message.c_str() << std::endl;
    };

    client->setErrorCallback(clientErrorCallback);

    auto authFailedCallback = [](const Nakama::NError& error)
    {
        std::cout << "Error[auth]: " << static_cast<int>( error.code ) << " " << error.message.c_str() << std::endl;
    };

    client->authenticateEmail(
        "test@test.com",
        "12345678",
        myUserName,
        true,
        vars,
        std::bind(&onAuthSucceeded, std::placeholders::_1),
        authFailedCallback
    );

    Nakama::NRtDefaultClientListener listener;
    listener.setNotificationsCallback([](const Nakama::NNotificationList & nots){
        std::cout << "Notification" << std::endl;
    });

    listener.setStatusPresenceCallback([](const Nakama::NStatusPresenceEvent& presence){
        std::cout << "Status presence" << std::endl;
    });

    listener.setStreamPresenceCallback([](const Nakama::NStreamPresenceEvent& presence){
        std::cout << "Stream presence" << std::endl;
    });

    listener.setStreamDataCallback([](const Nakama::NStreamData& data){
        std::cout << "Stream data" << std::endl;
    });

    listener.setErrorCallback([](const Nakama::NRtError& error){
        std::cout << "Error: " << error.message << std::endl;
    });

    listener.setDisconnectCallback([](const Nakama::NRtClientDisconnectInfo& info){
        std::cout << "Disconnect: " << info.reason << std::endl;
    });

    listener.setConnectCallback([]()
    {
        std::cout << "Connected" << std::endl;
    });

    bool done = false;
    while( !done )
    {
        client->tick();

        if ( m_session && m_session->isExpired() ) {
            std::cout << "expired" << std::endl;
            exit(EXIT_SUCCESS);
        }

        if( rtClient )
        {
            rtClient->tick();

            if ( stateMachine == 2 && !rtClient->isConnected() ) {
                std::cout << "disconnected" << std::endl;
                rtClient = nullptr;
            } else if ( stateMachine == 1 && rtClient->isConnected() ) {
                std::cout << "connected" << std::endl;
                stateMachine = 2;
            } else if ( stateMachine == 0 ) {
                rtClient->setListener(&listener);

                bool createStatus = true; // if the socket should show the user as online to others.
                rtClient->connect(m_session, createStatus);
                stateMachine = 1;
            }
        } else if ( stateMachine == 2 ) {
            std::cout << "disconnected [null rtClient]" << std::endl;
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }

    return EXIT_SUCCESS;
}