//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2013-2015 SuperTuxKart-Team
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include "network/protocol.hpp"

#include "network/event.hpp"
#include "network/network_string.hpp"
#include "network/protocol_manager.hpp"
#include "network/stk_host.hpp"
#include "network/stk_peer.hpp"

/** \brief Constructor
 *  Sets the basic protocol parameters, as the callback object and the
 *  protocol type.
 *  \param callback_object The callback object that will be used by the
 *          protocol. Protocols that do not use callback objects must set
 *          it to NULL.
 *  \param type The type of the protocol.
 */
Protocol::Protocol(ProtocolType type, CallbackObject* callback_object)
{
    m_callback_object       = callback_object;
    m_type                  = type;
    m_state                 = PROTOCOL_STATE_INITIALISING;
    m_handle_connections    = false;
    m_handle_disconnections = false;
}   // Protocol

// ----------------------------------------------------------------------------
/** \brief Destructor.
 */
Protocol::~Protocol()
{
}   // ~Protocol

// ----------------------------------------------------------------------------
/** Returns a network string with the given type.
 *  \capacity Default preallocated size for the message.
 */
NetworkString* Protocol::getNetworkString(size_t capacity)
{
    return new NetworkString(m_type, (int)capacity);
}   // getNetworkString

// ----------------------------------------------------------------------------
/** Checks if the message has at least the specified size, and if not prints
 *  a warning message including the message content.
 *  \return True if the message is long enough, false otherwise.
 */
bool Protocol::checkDataSize(Event* event, unsigned int minimum_size)
{
    const NetworkString &data = event->data();
    if (data.size() < minimum_size)
    {
        Log::warn("Protocol", "Receiving a badly formated message:");
        Log::warn("Protocol", data.getLogMessage().c_str());
        return false;
    }
    return true;
}   // checkDataSize

// ----------------------------------------------------------------------------
/** Starts a request in the protocol manager to start this protocol. 
 */
void Protocol::requestStart()
{
    if (auto pm = ProtocolManager::lock())
        pm->requestStart(shared_from_this());
}   // requestStart

// ----------------------------------------------------------------------------
/** Submits a request to the ProtocolManager to pause this protocol.
 */
void Protocol::requestPause()
{
    if (auto pm = ProtocolManager::lock())
        pm->requestPause(shared_from_this());
}   // requestPause

// ----------------------------------------------------------------------------
/** Submits a request to the ProtocolManager to unpause this protocol.
 */
void Protocol::requestUnpause()
{
    if (auto pm = ProtocolManager::lock())
        pm->requestUnpause(shared_from_this());
}   // requestUnpause

// ----------------------------------------------------------------------------
/** Submits a request to the ProtocolManager to terminate this protocol.
 */
void Protocol::requestTerminate()
{
    if (auto pm = ProtocolManager::lock())
        pm->requestTerminate(shared_from_this());
}   // requestTerminate

// ----------------------------------------------------------------------------
/** Sends a message to all validated peers in game, encrypt the message if
 *  needed. The message is composed of a 1-byte message (usually the message
 *  type) followed by the actual message.
 *  \param message The actual message content.
*/
void Protocol::sendMessageToPeers(NetworkString *message, bool reliable)
{
    STKHost::get()->sendPacketToAllPeers(message, reliable);
}   // sendMessageToPeers

// ----------------------------------------------------------------------------
/** Sends a message to all validated peers in server, encrypt the message if
 *  needed. The message is composed of a 1-byte message (usually the message
 *  type) followed by the actual message.
 *  \param message The actual message content.
*/
void Protocol::sendMessageToPeersInServer(NetworkString* message,
                                          bool reliable)
{
    STKHost::get()->sendPacketToAllPeersInServer(message, reliable);
}   // sendMessageToPeersInServer

// ----------------------------------------------------------------------------
/** Sends a message from a client to the server.
 */
void Protocol::sendToServer(NetworkString *message, bool reliable)
{
    STKHost::get()->sendToServer(message, reliable);
}   // sendMessage