#include "../include/iomanager.hpp"

#include <iostream>
#include <jsoncpp/json/json.h>

using boost::asio::buffer;

IoManager::IoManager(char *ipcstring) {
  ipstring = new std::string(ipcstring);
  port = 1234;
  tcpsock = new tcp::socket(ios);
}

bool IoManager::connect() {
  boost::asio::streambuf recvbuf;
  tcp::endpoint *ep;
  Json::Value root, checkok;
  const char *recvjson;
  std::string jsonerror;
  bool bcheckok;

  Json::CharReaderBuilder rbuilder;
  const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
  Json::StreamWriterBuilder wbuilder;
  // builder["indentation"] = ""; // If you want whitespace-less output
  // const std::string output = Json::writeString(wbuilder, root);

  ep =
      new tcp::endpoint(boost::asio::ip::address::from_string(*ipstring), 1234);

  // establish connection
  std::cerr << "connecting to " << *ipstring << std::endl;
  tcpsock->connect(*ep, errcode);
  if (errcode) {
    std::cerr << "couldnt connect to " << *ipstring << std::endl
              << errcode.message() << std::endl;
    return false;
  }

  printf("connect ok\n");
  fflush(stdout);

  // send version check
  root["version"] = VERSION;

  std::cout << root << std::endl;

  boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
                     errcode);
  if (errcode) {
    std::cerr << "couldnt send version check" << std::endl
              << errcode.message() << std::endl;
    return false;
  }

  printf("send ok\n");
  fflush(stdout);

  // recieve answer to version check
  // using transfer_at_least(1) to avoid lockup with transfer_all()
  boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
                    errcode);
  //~ boost::asio::read(*tcpsock, recvbuf, errcode);
  if (errcode && errcode != boost::asio::error::eof) {
    std::cerr << "couldnt recieve version check" << std::endl
              << errcode.message() << std::endl;
    return false;
  }

  printf("recieve ok\n");
  fflush(stdout);

  // parse json
  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
  if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
    std::cerr << "couldnt parse recieved json" << std::endl
              << jsonerror << std::endl;
    return false;
  }

  printf("parse ok\n");
  fflush(stdout);

  // remove processed data from recvbuf
  recvbuf.consume(recvbuf.size());

  std::cout << root << std::endl;

  // check if version check was ok
  checkok = root["accept"];

  if (!checkok.asBool()) {
    std::cerr << "version check failed. client version is " << VERSION
              << std::endl
              << "server reports version " << root["version"] << std::endl;
    return false;
  }

  printf("check ok\n\n\n");
  fflush(stdout);

  /* */
  // TODO remove hardcoded login
  root = Json::Value();
  // send version check
  // TODO make client version global
  root["user"] = "user";
  root["pass"] = "pass";

  std::cout << root << std::endl;

  boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
                     errcode);
  if (errcode) {
    std::cerr << "couldnt send login" << std::endl
              << errcode.message() << std::endl;
    return false;
  }

  printf("send ok\n");
  fflush(stdout);

  // recieve answer to version check
  // using transfer_at_least(1) to avoid lockup with transfer_all()
  boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
                    errcode);
  //~ boost::asio::read(*tcpsock, recvbuf, errcode);
  if (errcode && errcode != boost::asio::error::eof) {
    std::cerr << "couldnt recieve login response" << std::endl
              << errcode.message() << std::endl;
    return false;
  }

  printf("recieve ok\n");
  fflush(stdout);

  // parse json
  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
  if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
    std::cerr << "couldnt parse recieved json" << std::endl
              << jsonerror << std::endl;
    return false;
  }

  printf("parse ok\n");
  fflush(stdout);

  // remove processed data from recvbuf
  recvbuf.consume(recvbuf.size());

  std::cout << root << std::endl;
  /* */

  // clean up
  delete ep;

  return true;
}

IoManager::~IoManager() {

  /* */

  boost::asio::streambuf recvbuf;
  Json::Value root, checkok;
  const char *recvjson;
  std::string jsonerror;

  Json::CharReaderBuilder rbuilder;
  const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
  Json::StreamWriterBuilder wbuilder;

  // TODO remove hardcoded login
  root = Json::Value();
  // send version check
  // TODO make client version global
  root["command"] = "close";

  std::cout << root << std::endl;

  boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
                     errcode);
  if (errcode) {
    std::cerr << "couldnt send close" << std::endl
              << errcode.message() << std::endl;
  }

  printf("send ok\n");
  fflush(stdout);

  // recieve answer to version check
  // using transfer_at_least(1) to avoid lockup with transfer_all()
  boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
                    errcode);
  //~ boost::asio::read(*tcpsock, recvbuf, errcode);
  if (errcode && errcode != boost::asio::error::eof) {
    std::cerr << "couldnt recieve close response" << std::endl
              << errcode.message() << std::endl;
  }

  printf("recieve ok\n");
  fflush(stdout);

  // parse json
  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
  if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
    std::cerr << "couldnt parse recieved json" << std::endl
              << jsonerror << std::endl;
  }

  printf("parse ok\n");
  fflush(stdout);

  // remove processed data from recvbuf
  recvbuf.consume(recvbuf.size());

  std::cout << root << std::endl;
  /* */

  tcpsock->close();

  delete ipstring;
  delete tcpsock;
}