#ifndef __Socket_h__
#define __Socket_h__

#include "includes"
#include "Object.h"

namespace core {

   class EPoll;

   ///
   /// Socket
   ///
   /// The core component to managing a socket.
   /// 
   /// Hooks into the EPoll through the registration and unregistration process and provides a
   /// communication socket of the specified protocol type. This object provides for all receiving
   /// data threading through use of the EPoll object and also provides buffering for output data
   /// requests to the socket.  
   ///
   /// A program using a socket object can request to open a socket (file or network or whatever) and
   /// communicate through the streambuffer interface of the socket object. 
   ///
   /// The socket side of the Socket accepts EPOLLIN event and will maintain the data in a buffer
   /// for the stream readers to read. A onDataReceived event is then sent with the data received in 
   /// the buffer that can be read through the stream.
   ///
   /// When writing to the stream the data is written into a buffer and a EPOLLOUT is scheduled. Upon
   /// receiving the EPOLLOUT event then the buffer is written to the socket output. 
   ///

   class Socket : public core::Object {
   
    public:

      Socket(EPoll &ePoll);
      Socket(EPoll &ePoll, std::string text);
      ~Socket();

      ///
      /// Use the shutdown() method to terminate the socket connection and remove resources.
      /// This method is provided to ensure that all destructors are called for all inherited
      /// objects without a virtual destructor.
      ///

      void shutdown(std::string text = "unknown");

      ///
      /// setDescriptor establishes the file descriptor for the socket and registers the socket
      /// on the EPoll controller. setDescriptor will invoke the onRegister() event. 
      ///
      
      void setDescriptor(int descriptor); ///<Set the descriptor for the socket.
   
      int getDescriptor(); ///< Get the descriptor for the socket.   

      class {
         int value;
   
       public:
         int & operator = (const int &i) { return value = i; }
         operator int () const { return value; }
   
      } bufferSize; ////> The descriptor to monitor for this socket.
         
      ///
      /// The event received from epoll is sent through the eventReceived
      /// method which will parse the event and call the read and write
      /// callbacks on the socket. 
      ///
      /// This method is called by the BMAEPoll object and should not be called
      /// from any user extended classes unless an epoll event is being
      /// simulated.
      ///
   
      bool eventReceived(struct epoll_event event); ///< Parse epoll event and call specified callbacks.

      ///
      /// Write data to the socket.
      ///
         
      int write(std::string data);
      void write(char *buffer, int length);

      void output(std::stringstream &out);

      ///
      /// The onRegister method is called before the socket is registered with 
      /// ePoll so objects extending the Socket definition can initialize the socket
      /// before receiving events. Evoked when the
      /// descriptor is set using setDescriptor for the socket.
      ///

      virtual void onRegister(); ///< Called when the socket has finished registering with the epoll processing.
      virtual void onRegistered();
      
      ///
      /// The onUnregister method is called whenever the socket is unregistered with 
      /// ePoll and socket communcation events will be stopped. The default method will
      /// close the socket and clean up the connection. If this is overridden by an
      /// extended object then the object should call this method to clean the socket up.
      ///

      virtual void onUnregister(); ///< Called when the socket has finished unregistering for the epoll processing.

      bool needsToWrite();

      bool active = false;

    protected:

      EPoll &ePoll;           // The EPoll control object.

      bool shutDown = false;

      void setBufferSize(int length);
   
      ///
      /// The onConnected method is called when the socket is ready to communicate. 
      /// Writing to the socket can begin on this call to initiate a contact with the
      /// remote device.
      ///
   
//      virtual void onConnected(); ///< Called when socket is open and ready to communicate.

      ///
      ///
      ///

//   virtual void onDisconnected(); ///< Called when socket is closing and no longer ready to communicate.
   
      ///
      /// The onDataReceived method is called when the socket has received an event from
      /// epoll and there is data ready to be read from the socket. The default handler 
      /// will pull the data and put it into the streambuf for the socket. EPOLLIN
      ///
      /// @param data the data that has been received from the socket.
      ///
   
      virtual void onDataReceived(std::string data); ///< Called when data is received from the socket.

      virtual void onDataReceived(char *buffer, int len); 
      
      ///
      /// receiveData will read the data from the socket and place it in the socket buffer.
      /// TLS layer overrides this to be able to read from SSL.
      ///

      virtual void receiveData(char *buffer, int bufferLength);
          
    private:

      std::string text;
      int descriptor = -1;
      std::mutex lock;
      std::mutex socketLock;
      bool readHangup = false;

//      struct epoll_event event;  // Event selection construction structure.

      //-------------------------------------------------------------------------------------
      // the writeSocket is called when epoll has received a write request for a socket. 
      // Writing data to this socket is queued in the streambuf and permission is requested
      // to write to the socket. This routine handles the writing of the streambuf data
      // buffer to the socket.
      //-------------------------------------------------------------------------------------   
   
      void writeSocket();

 //  int_type underflow();
//   int_type uflow();
//   int_type pbackfail(int_type ch);
//   streamsize showmanyc();

      char *buffer;     // This is a pointer to the managed buffer space.
      int length;       // This is the length of the buffer.

//   const char * const begin_;
//   const char * const end_;
//   const char * const current_;

      std::queue<std::string> fifo;
      
   };

}

#endif