#ifndef SESSION_H
#define SESSION_H

#include <boost/asio.hpp>
#include <boost/asio/ip/basic_resolver.hpp>
#include <string>

#define MAX_BUFFER 256

/*
Dispatch Manager:


Handles:
  [ ] Does whatever we received from the server get sent to the client?
      [SHOW-CLIENT]
  [ ] Where does client input go? [CLIENT]
  [ ] Client input go directly to the server? [TALK-DIRECT]
  [ ] Where does server input go? [SERVER-LINE] [SERVER-PROMPT]

I'm thinking a dispatcher would know how to:
  [ ] Save the current state (and current dispatcher/setup).
  [ ] Set itself up with the director.
  [ ] Restore the previous state (when destructing -- but only if it is the
      current active receiver).
  [ ] Take a command [goto SECTOR][trade FOE] (fuel organics equipment),
      and return a result.  [1 SUCCESS][0 FAIL][-1 USER ABORTED]
  [ ] Tell director where results should go (callback).
  [ ] Tell director where callback messages/events should go.  (dynamic)


Director:
  [ ] Handles server lines, server prompt, client input.
  [ ] Has to_client, to_server.
  [ ] Has low-level flags for show_client, talk-direct
  [ ] Has a std::stack of dispatchers.  Uses .top() for calls.
  [ ] Reset -- would pop all but the last/master dispatchers.


It seems like the director wants to be the session, or at least parts of it.

 */

/*
The session:

 */

class session : public std::enable_shared_from_this<session> {
public:
  session(boost::asio::ip::tcp::socket socket,
          boost::asio::io_service &io_service, std::string hostname,
          std::string port);
  void start(void);

  ~session();

  void parse_auth(void);
  void on_connect(const boost::system::error_code error);

  void server_read(void);
  void on_resolve(const boost::system::error_code error,
                  const boost::asio::ip::tcp::resolver::results_type results);
  void do_read(void);
  void to_client(std::string message);
  void to_server(std::string message);
  void on_shutdown(boost::system::error_code ec);

  void dispatch_line(std::string line);
  void process_lines(std::string &received);

private:
  // FOR NOW:  These will go into the director
  bool show_client = true;
  bool talk_direct = true;

  /**
   * The client's socket
   */
  boost::asio::ip::tcp::socket socket_;
  boost::asio::io_service &io_service_;
  boost::asio::ip::tcp::resolver resolver_;
  /**
   * The server's socket
   */
  boost::asio::ip::tcp::socket server_;

  /**
   * The time that we'll use to fire off the "prompt" event.
   *
   * The idea being that we'd receive chars, processing lines.
   * And if we have something in server_prompt start the timer.
   * If we receive more, process lines, if !server_prompt.empty()
   * reset the timer.
   *
   * If the timer fires (and isn't aborted), fire off the prompt.
   *
   * I'm not so sure about this -- because this adds delay to the
   * proxy.  [It might be better to just fire off "some" text, and
   * have it ignored, rather then adding a delay.]  Or, this might
   * not matter at all, I'm thinking milliseconds here!
   */
  boost::asio::high_resolution_timer timer_;

  /**
   * What characters have been received from the server,
   * that weren't \n terminated?
   *
   * This needs to be reset/cleared if there's a \r (carriage return).
   */
  std::string server_prompt;
  /**
   * FAIL-WHALE: This was supposed to hold the number of characters
   * already sent to the user at this point in time, but I'm having
   * a hard time tracking those.
   *
   */
  int server_sent;

  /**
   * The client read buffer.
   *
   * This is too big, we don't get that many characters from the client.
   *
   */
  char read_buffer[MAX_BUFFER + 1];
  /**
   * The server read buffer.
   * This is MAX_BUFFER + 1 (to store the \0 to terminate the string)
   */
  char server_buffer[MAX_BUFFER + 1];

  /**
   * The rlogin information received from the client.
   *
   * We check this, and if it isn't valid, we spoof some rlogin
   * connection.
   */
  std::string rlogin_auth;
  /**
   * The username passed in via rlogin.  We need this so we know what
   * name we need to store the data under.
   */
  std::string rlogin_name;
  std::string host;
  std::string port;

  /**
   * Are we connected to the server?
   *
   * Don't shutdown the server socket if we aren't connected.
   */
  bool connected = false;
};

/*
maybe move the resolver part to the server, so I don't need io_service?

I'm not sure what the socket connection part is going to need just yet,
so I probably won't move that just yet.  [NNY!]

*/

class server {

public:
  server(boost::asio::io_service &io_service,
         const boost::asio::ip::tcp::endpoint &endpoint, std::string host,
         std::string port);

private:
  void do_accept(void);

  boost::asio::io_service &io_service_;
  boost::asio::ip::tcp::acceptor acceptor_;
  /**
   * The host to connect to (from config)
   */
  std::string host_;
  /**
   * The port to connect to (from config)
   *
   */
  std::string port_;
};

// The simple way to get the boost logging to log file and line number information.
#include <string.h>
#include <iomanip>

// I don't gain anything from this being constexpr
const char * trim_path( const char * filepath );

#define BUGZ_LOG(severity) BOOST_LOG_TRIVIAL(severity) << "(" << std::setw(15) << trim_path( __FILE__ ) << ":" << std::setw(4) << std::left << __LINE__ << ") "

#endif