/* Copyright (C) 2014 InfiniDB, Inc.

   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; version 2 of
   the License.

   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., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/******************************************************************************
 * $Id$
 *
 *****************************************************************************/

/** @file umsocketselector.h
 * Used in selecting the "next" socket/port when sending a response message
 * to a UM module.  UmSocketSelector is the public API class.  UmModuleIPs
 * is a supporting class of UmSocketSelector, and UmIPSocketConns is in turn
 * a supporting class of UmModuleIPs.
 */

#ifndef UMSOCKETSELECTOR_H__
#define UMSOCKETSELECTOR_H__

#ifdef _MSC_VER
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#include <stdint.h>
typedef uint32_t in_addr_t;
#else
#include <netinet/in.h>
#endif
#include <list>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>

#include "iosocket.h"

namespace primitiveprocessor
{
class UmModuleIPs;
class UmIPSocketConns;

typedef boost::shared_ptr<UmModuleIPs>     SP_UM_MODIPS;
typedef boost::shared_ptr<UmIPSocketConns> SP_UM_IPCONNS;
typedef boost::shared_ptr<messageqcpp::IOSocket>		   SP_UM_IOSOCK;
typedef boost::shared_ptr<boost::mutex>	   SP_UM_MUTEX;

//------------------------------------------------------------------------------
/** @brief Public API class used to track and select socket for outgoing msgs.
 *
 * This class maintains a list of UM's and the corresponding IP addresses for
 * each UM.  In addition, a list of socket/port connections are maintained for
 * each IP addresss.  nextIOSocket() can be used to iterate through all the IP
 * addresses and socket/port connections for a given UM, as response messages
 * are sent to the UM.  This action attempts to see that the output network
 * traffic is evenly distributed among all the NIC's for a UM.
 *
 * This class is not entirely thread-safe, as the first call to instance() must
 * be made from a single threaded envirionment as part of initialization. After
 * that, the class is thread-safe through the use of a mutex in UmModuleIPs.
 */
//------------------------------------------------------------------------------
class UmSocketSelector
{
public:
    typedef std::map<in_addr_t, unsigned int> IpAddressUmMap_t;

    /** @brief Singleton accessor to UmSocketSelector instance.
     *
     * This method should be called once from the main thread to perform
     * initialization from a single threaded environment.
     */
    static UmSocketSelector* instance();

    /** @brief UmSocketSelector destructor
     *
     */
    ~UmSocketSelector()
    { };

    /** @brief Accessor to total number of UM IP's in Columnstore.xml.
     *
     * @return Number of UM IP addresses read from Columnstore.xml.
     */
    uint32_t ipAddressCount() const;

    /** @brief Add a socket/port connection to the connection list.
     *
     * @param ios (in) socket/port connection to be added.
     * @param writeLock (in) mutex to use when writing to ios.
     * @return boolean indicating if socket/port connection was added.
     */
    bool addConnection( const SP_UM_IOSOCK& ios,
                        const SP_UM_MUTEX& writeLock );

    /** @brief Delete a socket/port connection from the connection list.
     *
     * @param ios (in) socket/port connection to be removed.
     */
    void delConnection( const messageqcpp::IOSocket& ios );

    /** @brief Get the next output IOSocket to use for the specified ios.
     *
     * @param ios (in) socket/port connection for the incoming message.
     * @param outIos (out) socket/port connection to use for the response.
     * @param writeLock (out) mutex to use when writing to outIos.
     * @return boolean indicating if operation was successful.
     */
    bool nextIOSocket( const messageqcpp::IOSocket& ios, SP_UM_IOSOCK& outIos,
                       SP_UM_MUTEX& writeLock );

    /** @brief toString method used in logging, debugging, etc.
     *
     */
    const std::string toString() const;

private:
    //...Disable default copy constructor and assignment operator by
    //   declaring but not defining
    UmSocketSelector  (const UmSocketSelector& rhs);
    UmSocketSelector& operator=(const UmSocketSelector& rhs);

    UmSocketSelector();
    void loadUMModuleInfo();
    unsigned int findOrAddUm( const std::string& moduleName );

    static UmSocketSelector* fpUmSocketSelector;
    std::vector<SP_UM_MODIPS> fUmModuleIPs; // UM's and their sockets

    // std::map that maps an IP address to an index into fUmModuleIPs
    IpAddressUmMap_t		  fIpAddressUmMap;
};

//------------------------------------------------------------------------------
/** @brief Tracks and selects "next" socket/port for a UM module.
 *
 * This is a supporting class to UmSocketSelector.
 * This class maintains a list of IP addresses (and their corrresponding
 * socket/port connections) for a specific UM module.  UmModuleIPs can
 * be used to iterate through the available IP addresses (and socket/port
 * connections) for a UM module, as response messages are sent out by PrimProc.
 *
 * This class is thread-safe.
 */
//------------------------------------------------------------------------------
class UmModuleIPs
{
public:
    /** @brief UmModuleIPs constructor.
     *
     * @param moduleName (in) UM module name for this UmModuleIPs object.
     */
    explicit UmModuleIPs ( const std::string& moduleName ) :
        fUmModuleName(moduleName),
        fNextUmIPSocketIdx(NEXT_IP_SOCKET_UNASSIGNED)
    { }

    /** @brief UmModuleIPs destructor.
     *
     */
    ~UmModuleIPs ( )
    { };

    /** @brief Accessor to number of IP's from Columnstore.xml for this UM.
     *
     * @return Number of IP addresses read from Columnstore.xml for this UM.
     */
    uint32_t ipAddressCount() const
    {
        return fUmIPSocketConns.size();
    }

    /** @brief Accessor to the module name for this UmModuleIPs object.
     *
     * @return UM module name.
     */
    const std::string& moduleName() const
    {
        return fUmModuleName;
    }

    /** @brief Add an IP address to this UM module.
     *
     * @param ip (in) IP address to be added (in network byte order)
     */
    void addIP         ( in_addr_t ip );

    /** @brief Add specified socket/port to the connection list for this UM.
     *
     * @param ioSock (in) socket/port to add to the connection list.
     * @param writeLock (in) mutex to use when writing to ioSock.
     * @return boolean indicating if socket/port connection was added.
     */
    bool addSocketConn ( const SP_UM_IOSOCK& ioSock,
                         const SP_UM_MUTEX& writeLock );

    /** @brief Delete specified socket/port from the connection list.
     *
     * @param ioSock (in) socket/port to delete from the connection list.
     */
    void delSocketConn ( const messageqcpp::IOSocket& ioSock );

    /** @brief Get the "next" available socket/port for this UM module.
     *
     * @param outIos (out) socket/port connection to use for the response.
     * @param writeLock (out) mutex to use when writing to outIos.
     * @return bool flag indicating whether a socket/port was available.
     */
    bool nextIOSocket  ( SP_UM_IOSOCK& outIos, SP_UM_MUTEX& writeLock );

    /** @brief toString method used in logging, debugging, etc.
     *
     */
    const std::string toString();

private:
    void advanceToNextIP();

    static const int32_t	NEXT_IP_SOCKET_UNASSIGNED;
    std::string				fUmModuleName;      // UM module name
    int32_t					fNextUmIPSocketIdx; //index to "next" IP address
    boost::mutex            fUmModuleMutex;

    // collection of IP addresses and their corresponding socket/port conns
    std::vector<SP_UM_IPCONNS> fUmIPSocketConns;
};

//------------------------------------------------------------------------------
/** @brief Tracks and selects "next" socket/port for a UM module IP address.
 *
 * This is a supporting class to UmModuleIPs.
 * This class maintains a list of socket/port connections for a specific UM
 * module IP address.  UmIPSocketConns can be used to iterate through the
 * available connections for an IP address, as response messages are sent out
 * by PrimProc.
 *
 * This class by itself is not thread-safe.  However, UmModulesIPs, which
 * uses UmIPSocketConns, insures thread-safeness.
 */
//------------------------------------------------------------------------------
class UmIPSocketConns
{
public:
    struct UmIOSocketData
    {
        SP_UM_IOSOCK fSock; // an output IOSocket
        SP_UM_MUTEX	fMutex; // mutex to be use when writing to fSock
    };

    /** @brief UmIPSocketConns constructor.
     *
     * @param ip (in) IP address for this UmIPSocketConns object.
     */
    explicit UmIPSocketConns( in_addr_t ip ) :
        fIpAddress(ip),
        fNextIOSocketIdx(NEXT_IOSOCKET_UNASSIGNED)
    { }

    /** @brief UmIPSocketConns destructor.
     *
     */
    ~UmIPSocketConns( )
    { }

    /** @brief Accessor to the IP address for this UmIPSocketConns object.
     *
     * @return IP address (in network byte order).
     */
    in_addr_t ipAddress ( )
    {
        return fIpAddress;
    }

    /** @brief Accessor to socket/port connection count for this IP address.
     *
     * @return socket/port connection count.
     */
    uint32_t count( )
    {
        return fIOSockets.size();
    }

    /** @brief Add specified socket/port to the connection list.
     *
     * @param ioSock (in) socket/port to add to the connection list.
     * @param writeLock (in) mutex to use when writing to ioSock.
     */
    void addSocketConn ( const SP_UM_IOSOCK& ioSock,
                         const SP_UM_MUTEX& writeLock );

    /** @brief Delete specified socket/port from the connection list.
     *
     * @param ioSock (in) socket/port to delete from the connection list.
     */
    void delSocketConn ( const messageqcpp::IOSocket& ioSock );

    /** @brief Get the "next" available socket/port for this IP address.
     *
     * @param outIos (out) socket/port connection to use for the response.
     * @param writeLock (out) mutex to use when writing to outIos.
     */
    void nextIOSocket ( SP_UM_IOSOCK& outIos, SP_UM_MUTEX& writeLock );

    /** @brief Convert network byte ordered IP address to string
     *
     * @param ipString (out) IP address string;
     *  ipString must be an array of size INET_ADDRSTRLEN.
     * @return IP address string (same as ipString)
     */
    static char* nwToString( in_addr_t addr, char* ipString  );

    /** @brief toString method used in logging, debugging, etc.
     *
     */
    const std::string toString() const;

private:
    static const int32_t	NEXT_IOSOCKET_UNASSIGNED;
    in_addr_t				fIpAddress;  // IP address in network byte order
    int32_t					fNextIOSocketIdx;//index to "next" socket/port
    std::vector<UmIOSocketData> fIOSockets;//socket/port list for fIpAddress
};

}

#endif
