#include "MantidKernel/ErrorReporter.h"
#include "MantidKernel/ChecksumHelper.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/InternetHelper.h"
#include "MantidKernel/MantidVersion.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/ParaViewVersion.h"
#include "MantidKernel/FacilityInfo.h"

#include <Poco/ActiveResult.h>

#include <json/json.h>

namespace Mantid {
namespace Kernel {

namespace {
/// static logger
Logger g_log("ErrorReporter");
}
// const std::string ERROR_URL("http://errorreports.mantidproject.org/api/error");
// const std::string STARTUP_URL(
//    "http://posttestserver.com/post.php?dir=Mantid"); // dev location
// http://posttestserver.com/data/
//const std::string ERROR_URL("http://ptsv2.com/t/mantidmat/post");
const std::string ERROR_URL("http://localhost:8082/api/error");

//----------------------------------------------------------------------------------------------
// Constructor for ErrorReporter
ErrorReporter::ErrorReporter(std::string application)
    : m_application(application), m_errorActiveMethod(this, &ErrorReporter::sendErrorAsyncImpl) , m_exitCode("") {
      Types::Core::time_duration upTime(0,0,0,0);
      m_upTime = upTime;
    }

ErrorReporter::ErrorReporter(std::string application, Types::Core::time_duration startTime, std::string exitCode)
    : m_application(application), m_upTime(startTime), m_errorActiveMethod(this, &ErrorReporter::sendErrorAsyncImpl), m_exitCode(exitCode) {}

void ErrorReporter::sendErrorReport() {
  try {
    std::string message = this->generateErrorMessage();

    // send the report
    Poco::ActiveResult<int> result = m_errorActiveMethod(message);
  } catch (std::exception &ex) {
    g_log.debug() << "Send error report failure. " << ex.what() << '\n';
  }
}

std::string ErrorReporter::generateErrorMessage() {
    ::Json::Value message;

    // username
  message["uid"] = Kernel::ChecksumHelper::md5FromString(
      ConfigService::Instance().getUsername());
  // hostname
  message["host"] = Kernel::ChecksumHelper::md5FromString(
      ConfigService::Instance().getComputerName());

  // os name, version, and architecture
  message["osName"] = ConfigService::Instance().getOSName();
  message["osArch"] = ConfigService::Instance().getOSArchitecture();
  message["osVersion"] = ConfigService::Instance().getOSVersion();
  message["osReadable"] = ConfigService::Instance().getOSVersionReadable();

  #if defined(MAKE_VATES)
    // paraview
    message["ParaView"] = Kernel::ParaViewVersion::targetVersion();
  #else
    message["ParaView"] = 0;
  #endif

  // mantid version and sha1
  message["mantidVersion"] = MantidVersion::version();
  message["mantidSha1"] = MantidVersion::revisionFull();

  message["dateTime"] =
      Types::Core::DateAndTime::getCurrentTime().toISO8601String();

  message["upTime"] = to_iso_string(m_upTime);

  message["application"] = m_application;

  message["facility"] = ConfigService::Instance().getFacility().name();

  message["exitCode"] = m_exitCode;

  ::Json::FastWriter writer;
  return writer.write(message);
}

int ErrorReporter::sendErrorAsyncImpl(const std::string &message) {
  return this->sendReport(message, ERROR_URL);
}

int ErrorReporter::sendReport(const std::string &message,
                                 const std::string &url) {
  int status = -1;
  try {
    Kernel::InternetHelper helper;
    std::stringstream responseStream;
    helper.setTimeout(20);
    helper.setBody(message);
    status = helper.sendRequest(url, responseStream);
  } catch (Mantid::Kernel::Exception::InternetError &e) {
    status = e.errorCode();
    g_log.information() << "Call to \"" << url << "\" responded with " << status
                        << "\n" << e.what() << "\n";
  }

  return status;
}

} // namespace Kernel
} // namespace Mantid