#include <assert.h>
#include <fstream>
#include <errno.h>
#include <curl/curl.h>
#include "libjson.h"

// g++ -O2 -o memory_leak_test -lcurl -Ijson MemoryLeakTest.C -Wno-reorder json/Source/*.cpp

std::string get_file_contents(const char *filename)
{ // http://stackoverflow.com/questions/2602013/read-whole-ascii-file-into-c-stdstring
  std::ifstream in(filename, std::ios::in | std::ios::binary);
  if (in)
  {
    std::string contents;
    in.seekg(0, std::ios::end);
    contents.resize(in.tellg());
    in.seekg(0, std::ios::beg);
    in.read(&contents[0], contents.size());
    in.close();
    return(contents);
  }
  throw(errno);
}

static void verifyFile()
{
  std::string raw = get_file_contents("sample_result.json");
  int i = 0;
  while (true)
  {
    raw[0];
    if (!libjson::is_valid(raw))
    {
      std::cout<<"not valid"<<std::endl;
      return;
    }
    i++;
    if (!(i%10000))
      std::cout<<"i = "<<i<<std::endl;
  }
}

static int _startAfter = 0;

static void parseFileOnce(std::string contents)
{
  contents[0];
  try
  {
    JSONNode result = libjson::parse(contents);
    JSONNode::iterator messagesIt = result.find("messages");
    if (messagesIt == result.end())
    {
      std::cerr<<"COULD NOT FIND messages"<<std::endl;
      return;
    }
    JSONNode messages = *messagesIt;
    bool first = true;
    for (JSONNode::iterator messageIt = messages.begin();
	 messageIt != messages.end();
	 messageIt++)
    {
      JSONNode messageBody = *messageIt;
      if (first)
      {
	JSONNode::iterator idIt = messageBody.find("id");
	if (idIt == messageBody.end())
	{
	  std::cerr<<"COULD NOT FIND id"<<std::endl;
	  return;
	}
	JSONNode id = *idIt;
	if (id.type() != JSON_NUMBER)
	{
	  std::cerr<<"INVALID TYPE for id"<<std::endl;
	  return;
	}
	_startAfter = id.as_int();
	first = false;
      }
      // Find symbols array
      JSONNode::iterator symbolsIt = messageBody.find("symbols");
      if (symbolsIt == messageBody.end())
      {
	std::cerr<<"COULD NOT FIND symbols"<<std::endl;
	continue;
      }
      JSONNode symbols = *symbolsIt;
      for (JSONNode::iterator symbolIt = symbols.begin();
	   symbolIt != symbols.end();
	   symbolIt++)
      {
	JSONNode symbol = *symbolIt;
	// Find symbol
	JSONNode::iterator stockSymbolIt = symbol.find("symbol");
	if (stockSymbolIt == symbol.end())
	{
	  std::cerr<<"COULD NOT FIND symbol"<<std::endl;
	  continue;
	}

	JSONNode stockSymbol = *stockSymbolIt;
	std::string stockSymbolString = stockSymbol.as_string();
	if (stockSymbolString.empty())
	{ // This is NOT an error.  Someone could have listed $$ in a
	  // message and no stock symbols.
	  continue;
	}
	//stLiveMessage->symbols = explode(",", stockSymbolString);
      }
    }
  }
  catch (std::invalid_argument ex)
  {
    std::cerr<<"EXCEPTION in parse"<<std::endl;
    return;
  }
}

static void parseFile()
{
  std::string raw = get_file_contents("sample_result.json");
  int i = 0;
  while (true)
  {
    parseFileOnce(raw);
    i++;
    if (!(i%10000))
      std::cout<<"i = "<<i<<std::endl;
  }
}

static int writeCount = 0;
static int64_t byteCount = 0;

static std::string messageSoFar;

static size_t writeFunction(void *ptr, size_t size,
			    size_t nmemb, void *userdata)
{
  size_t bytes = size * nmemb;
  messageSoFar.append((char const *)ptr, bytes);
  writeCount++;
  byteCount+=bytes;
  return bytes;
}

static const std::string url = "https://secure.trade-ideas.com/static/curl_test/sample_result.json";
//static const std::string url = "http://static.trade-ideas.com/curl_test/sample_result.json";

static void testCurl()
{ // I added this because the documentation says it's a good idea.  If you
  // read the details, it was very unlikely this would fix the memory leak,
  // but it couldn't hurt.  As expected, adding this changed nothing.
  const CURLcode initResult = curl_global_init(CURL_GLOBAL_ALL);
  assert(!initResult);

  int i = 0;
  CURL *handle = NULL;
  while (true)
  {
    if (handle)
      curl_easy_reset(handle);
    else
      handle = curl_easy_init();
    curl_easy_setopt(handle, CURLOPT_URL, url.c_str());
    curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, writeFunction);
    //curl_easy_setopt(handle, CURLOPT_WRITEDATA, this);
    curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1);
    curl_easy_setopt(handle, CURLOPT_TIMEOUT, 15);
    curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, 5);
    messageSoFar.clear();
    CURLcode status = curl_easy_perform(handle);
    if (status != CURLE_OK)
    { //http://curl.haxx.se/libcurl/c/libcurl-errors.html
      std::cerr<<"CURL_ERROR "<<status<<std::endl;
      curl_easy_cleanup(handle);
      handle = NULL;
    }
    i++;
    if (!(i%100))
      std::cout<<"i = "<<i<<", writeCount = "<<writeCount
	       <<", byteCount = "<<byteCount<<std::endl;
  }
}

int main(int, char **)
{
  //verifyFile();
  //parseFile();
  // The two functions listed above caused no problems for me.  They were
  // running with version 7.6.0 of libjson, which I've been using for years.
  // There is a newer version, 7.6.1.  This came out about 3 month later,
  // about two years ago.  There have been no new releases after that.
  // The release notes duscuss several obsure bugs, but nothing about a
  // memory leak.

  // This function caused a memory leak.  The file I was reading was 30k.
  // each time I read the file, I had a memory leak of 15k.  I had the same
  // result with http and https.
  //
  // Update:  I did not see any memory leak running this program on
  // chuck-liddell, a very old system.  Then I tried "yum update libcurl".
  // That downloaded and installed new files.  That fixed the bug for HTTP.
  // But I still see an obvious memory leak under HTTPS.  (Some libraries on
  // chuck-liddell are too old, and I can't reliably access HTTPS using
  // curl from that machine.)  The memory leak might have even gotten worse
  // after I updated that library.
  //
  // Update:  I recently changed the logic to reuse the curl handle until
  // there is an error.  Only then will it destroy the old handle and create
  // a new one.  This works!  No more memory leak, and the code is much faster!
  // Of course, the leak is still hiding in there.  There will be failures,
  // so we will have to do the buggy operation.  Hopefully it will be
  // infrequent enough that it's not a problem.  But it can't run forever.  :(
  testCurl();  
}