#ifndef __TCPServer_h__
#define __TCPServer_h__

#include "Command.h"
#include "CommandList.h"
#include "IPAddressList.h"
#include "Socket.h"
#include "SubscriptionManager.h"
#include "TCPSession.h"
#include "TCPSocket.h"

namespace core
{

  ///
  /// TCPServer
  ///
  /// Manage a socket connection as a TCP server type. Connections to the socket are processed through
  /// the accept functionality.
  ///
  /// A list of connections is maintained in a vector object.
  ///
  /// This object extends the BMACommand object as well so it can be added to a Console object and
  /// process commands to display status information.
  ///

  class TCPServer : public TCPSocket, public Command
  {

  public:
    ///
    /// The constructor for the TCPServer object.
    ///
    /// @param ePoll the EPoll instance that manages the socket.
    /// @param url the IP address for the socket to receive connection requests.
    /// @param port the port number that the socket will listen on.
    /// @param commandName the name of the command used to invoke the status display for this object.
    ///

    TCPServer(EPoll &ePoll, IPAddress address, std::string delimiter = " ", int depth = 10, std::string text = "");

    ///
    /// The destructor for this object.
    ///

    virtual ~TCPServer();

    virtual void sessionErrorHandler(std::string errorString, std::stringstream &out);
    virtual bool compareAlias(void *alias, void *compare);
    ///
    /// getSocketAccept is designed to allow a polymorphic extension of this object to
    /// return a type of object that extends the definition of the server socket.
    /// Returning the appropriate session object that extends from Session provides
    /// the mechanism where the server can select the protocol dialog for the desired
    /// service.
    ///

    virtual TCPSession *getSocketAccept(EPoll &epoll);

    ///
    /// The list of sessions that are currently open and being maintained by this object.
    ///

    std::vector<TCPSession *> sessions;

    ///
    /// The commands object is a CommandList and is used to store Command objects to be
    /// parsed and run as data comes into the session.
    ///

    CommandList commands;

    ///
    /// If not NULL the blacklist object can be assigned to this server socket and the server
    /// IP addresses connecting to the server attempting to accept a socket are contained in
    /// this list then the connection is rejected and no accept is granted.
    ///

    IPAddressList *blackList;

    ///
    /// If not NULL the blacklist object can be assigned to this server socket and the server
    /// IP addresses connecting to the server attempting to accept a socket are contained in
    /// this list then the connection is rejected and no accept is granted.
    ///

    IPAddressList *whiteList;

    void removeFromSessionList(TCPSession *session);

    void output(std::stringstream &out); ///< Output the consoles array to the console.

    ///
    ///
    ///

    void sendToAll(std::stringstream &out);

    ///
    /// Use this sendToAll method to output the contents of the out stream
    /// to all the connections on the server excluding the sender session.
    ///

    void sendToAll(std::stringstream &out, TCPSession &sender, SessionFilter filter);

    ///
    /// Use this sendToAll method to output the contents of the out stream
    /// to all the connections on the server excluding the sender session
    /// and the entries identified by the passed in filter object.
    ///

    void sendToAll(std::stringstream &out, TCPSession &sender);

    ///
    /// The Subscription Manager tracks all subscriptions on the server.
    ///

    SubscriptionManager subscriptions;

    ///
    /// Use the getSessionByAlias to retrieve a session pointer by the value
    /// of the alias pointer.
    ///

    TCPSession *getSessionByAlias(void *alias);

  protected:
    ///
    /// Override the virtual dataReceived since for the server these
    /// are requests to accept the new connection socket.
    /// No data is to be read or written when this method is called. It is the response to
    /// the fact that a new connection is coming into the system
    ///
    /// @param data the pointer to the buffer containing the received data.
    /// @param length the length of the associated data buffer.
    ///

    void onDataReceived(std::string data) override;

    ///
    /// This method is called when the Command associated with this object is requested
    /// because a user has typed in the associated command name on a command entry line.
    ///
    /// @param the session object to write the output to.
    ///

    int processCommand(coreutils::ZString &request, TCPSession &session) override;

  private:
    TCPSession *accept();
    std::mutex lock;
  };

}

#endif