twproxy2/dispatchers.cpp

#include <boost/format.hpp>
#include <cctype>

#include "boxes.h"
#include "dispatchers.h"
#include "logging.h"

Dispatch::Dispatch(Session *s) : sess{s} {};

Dispatch::~Dispatch(){};

void Dispatch::to_server(const std::string &send) { sess->to_server(send); }
void Dispatch::to_client(const std::string &send) { sess->to_client(send); }
const std::string &Dispatch::get_prompt(void) { return sess->get_prompt(); }

void Dispatch::setNotify(notifyFunc nf) { notify_ = nf; }

void Dispatch::notify(void) {
  if (notify_) {
    sess->post(notify_);
    notify_ = nullptr;
  }
}

MainDispatch::MainDispatch(Session *s) : Dispatch{s}, id{s} {
  BUGZ_LOG(warning) << "MainDispatch()";
}

MainDispatch::~MainDispatch() { BUGZ_LOG(warning) << "~MainDispatch()"; }

void MainDispatch::activate(void) {
  // how to set this event to our method?
  sess->emit_server_line = [this](const std::string &s) { server_line(s); };
  sess->emit_server_prompt = [this](const std::string &s) { server_prompt(s); };
  sess->emit_client_input = nullptr;
  // sess->emit_client_input = [this](const std::string &s) { client_input(s);
  // };
  sess->show_client = false; // don not auto-send server to client
  sess->talk_direct = false; // do not auto-send client to server
  count = 0;
  old_prompt = sess->get_prompt();
  Boxes box(40, 1, 4);
  to_client("\n\r");
  to_client(box.top());
  std::string output = "Proxy ACTIVE! Welcome!";
  while (output.length() < 40)
    output.append(" ");

  to_client(box.row(output));
  to_client(box.bottom());
  to_client("\n\r\x1b[1;34mWELCOME!  You are now in the proxy zone...\n\r");
  id.prompt = "Proxy Main :=> ";
  id.max_length = 25;
  id.setNotify([this]() { this->have_input(); });
  id.activate();
}

void MainDispatch::have_input(void) {
  ++count;
  std::string output =
      str(boost::format("Your Input (%2%): [%1%]\n\r") % id.input % count);

  to_client(output);
  if (count >= 5) {
    to_client("Returning you to the game...\n\r");
    deactivate();
  } else {
    // prompt it again, sam.
    id.setNotify([this]() { this->have_input(); });
    id.activate();
  }
}

void MainDispatch::deactivate(void) {
  // Since we're the main thing there --
  sess->emit_server_line = nullptr;
  sess->emit_server_prompt = nullptr;
  sess->emit_client_input = nullptr;
  sess->show_client = true;
  sess->talk_direct = true;
  sess->set_prompt(old_prompt);
  notify();
}

void MainDispatch::server_line(const std::string &line) {
  BUGZ_LOG(info) << "MDSL: " << line;
  to_client("SL: ");
  to_client(line);
  to_client("\n\r");
}

void MainDispatch::server_prompt(const std::string &prompt) {
  BUGZ_LOG(info) << "MDSP: " << prompt;
}

#ifdef NEVERMORE
void MainDispatch::client_input(const std::string &input) {
  // I don't care what the old prompt looked liked at this point.
  BUGZ_LOG(warning) << "Got: " << input; //  << " prompt=" << get_prompt();

  // Serious problem when the input = "\x1b" ESC.  The output gets gummed/locked
  // up.
  if (input == "\x1b") {
    return;
  }

  ++count;
  std::string output = str(boost::format("MSG %1%: [%2%]\n\r") % count % input);
  to_client(output);
  if (count >= 5) {
    to_client("And we're outta here!\n\r");
    deactivate();
  }
}
#endif

InputDispatch::InputDispatch(Session *s) : Dispatch(s) {
  BUGZ_LOG(warning) << "InputDispatch()";
}

void InputDispatch::activate(void) {
  ds = sess->save_settings();
  sess->emit_server_line = [this](const std::string &s) { server_line(s); };
  sess->emit_server_prompt =
      nullptr; // [this](const std::string &s) { server_prompt(s); };
  sess->emit_client_input = [this](const std::string &s) { client_input(s); };
  sess->show_client = false; // don not auto-send server to client
  sess->talk_direct = false; // do not auto-send client to server

  input.clear();
  to_client(prompt);
}

void InputDispatch::deactivate(void) {
  sess->restore_settings(ds);
  notify();
}

void InputDispatch::server_line(const std::string &line) {}
// void InputDispatch::server_prompt(const std::string &prompt) {}

void InputDispatch::client_input(const std::string &cinput) {
  for (const char ch : cinput) {
    if (isprint(ch)) {
      // Ok!
      if (input.length() < max_length) {
        to_client(std::string(1, ch));
        input += ch;
      }
    } else if ((ch == '\b') || (ch == 0x7f)) {
      // Backspace or rubout
      if (input.length() > 0) {
        to_client("\b \b");
        input.erase(input.size() - 1);
      }
    } else if (ch == '\r') {
      // Ok, we're done!
      BUGZ_LOG(info) << "InputDispatch done: " << input;
      to_client("\n\r");
      deactivate();
    }
  }
}

/*
 * CoreDispatch:  This is an example class that does dispatch.
 * Copy this and make changes from there...
 */
CoreDispatch::CoreDispatch(Session *s) : Dispatch{s} {
  BUGZ_LOG(warning) << "CoreDispatch()";
}

void CoreDispatch::activate(void) {
  // save things, set things
}

void CoreDispatch::deactivate(void) {
  // restore things
  notify();
}

void CoreDispatch::server_line(const std::string &line) {}
void CoreDispatch::server_prompt(const std::string &prompt) {}
void CoreDispatch::client_input(const std::string &input) {
  BUGZ_LOG(warning) << "Got: " << input << " prompt=" << get_prompt();
}