#include <curl/curl.h>
#include <iostream>
#include <sstream>
#include <unistd.h>
#include "libjson.h"

#include "../shared/DatabaseWithRetry.h"
#include "../shared/DatabaseSupport.h"
#include "../shared/GlobalConfigFile.h"
#include "../generate_alerts/misc_framework/AccumulateInsert.h"

AccumulateInsert _insertAccumulator();
// Stocktwits does not remember state.  We have to tell it the last thing
// that we saw, so it can restart after that.  Otherwise we'd get duplicates.
int64_t _startAfter;
CURL *_curlHandle;

// We accumulate the entire result from stocktwits, and parses the entire
// thing at once.
std::string _result;

// Every time we get data from curl, it calls writeFunction
size_t writeFunction(void *ptr, size_t size,
size_t nmemb, void *unused)
{
  size_t bytes = size * nmemb;
  _result.append((char const *)ptr, bytes);
  return bytes;
}


// StreamingDataThread updated to use the new StockTwits API requiring authentication.
// Also note that the streams/all method changed the response format.
void checkForData(DatabaseWithRetry &db)
{
  std::string url = "https://api.stocktwits.com/api/2/streams/all.json";
  url += "?access_token=496ae4e0b026d197113b19942488069a2c7b7d45";
  if (_startAfter)
  {
    url += "&since=";
    url += ntoa(_startAfter);
  }
  
  if (_curlHandle)
  curl_easy_reset(_curlHandle);
  else 
  _curlHandle = curl_easy_init();
  curl_easy_setopt(_curlHandle, CURLOPT_URL, url.c_str());
  curl_easy_setopt(_curlHandle, CURLOPT_WRITEFUNCTION, writeFunction);
  curl_easy_setopt(_curlHandle, CURLOPT_WRITEDATA, NULL);
  curl_easy_setopt(_curlHandle, CURLOPT_NOSIGNAL, 1);
  curl_easy_setopt(_curlHandle, CURLOPT_TIMEOUT, 15);
  curl_easy_setopt(_curlHandle, CURLOPT_CONNECTTIMEOUT, 5);
  _result.clear();
  // // tm.setState("curl_easy_perform()");
  CURLcode status = curl_easy_perform(_curlHandle);
  if (status != CURLE_OK)
  { //http://curl.haxx.se/libcurl/c/libcurl-errors.html
    // tm.increment("CURL_ERROR " + ntoa(status));
    curl_easy_cleanup(_curlHandle);
    _curlHandle = NULL;
    return;
  }
  // // tm.setState("verify");
  // It seems like we can make our error handling a lot simpler by validating
  // the entire file here.  By default the library does lazy parsing.
  if (!libjson::is_valid(_result))
  {
    // tm.increment("JSON not valid");
    return;
  }
  // // tm.setState("parse string");
  try
  {
    JSONNode result = libjson::parse(_result);
    // // tm.setState("parse ojbect");
    //std::cout<<_result<<std::endl;
    // Find messages
    JSONNode::iterator messagesIt = result.find("messages");
    if (messagesIt == result.end())
    {
      // tm.increment("COULD NOT FIND messages");
      return;
    }
    JSONNode messages = *messagesIt;
    bool first = true;
    for (JSONNode::iterator messageIt = messages.begin();
    messageIt != messages.end();
    messageIt++)
    {
      JSONNode messageBody = *messageIt;
      if (first)
      {
        // This is documented somewhat in the PHP version.  StockTwits
        // said we should always grab the message id from the first 
        // message and send that back next time as "since=".  Note that
        // this is usually the highest number of all the message ids,
        // but not always.
        // Find id
        JSONNode::iterator idIt = messageBody.find("id");
        if (idIt == messageBody.end())
        {
          // tm.increment("COULD NOT FIND id");
          return;
        }
        JSONNode id = *idIt;
        if (id.type() != JSON_NUMBER)
        {
          // tm.increment("INVALID TYPE for id");
          return;
        }
        _startAfter = id.as_int();
        first = false;
      }
      JSONNode::iterator userIt = messageBody.find("user");
      if (userIt == messageBody.end())
      {
        // tm.increment("COULD NOT FIND user");
        return;
      }
      JSONNode userBody = *userIt;
      JSONNode::iterator userIdIt = userBody.find("id");
      if (userIdIt == messageBody.end())
      {
        // tm.increment("COULD NOT FIND user id");
        return;
      }
      JSONNode userIdNode = *userIdIt;
      if (userIdNode.type() != JSON_NUMBER)
      {
        // tm.increment("INVALID TYPE for id");
        return;
      }
      int userId = userIdNode.as_int();
      JSONNode::iterator timeIt = messageBody.find("created_at");
      if (timeIt == messageBody.end())
      {
        // tm.increment("COULD NOT FIND created_at");
        return;
      }
      JSONNode time = *timeIt;
      if (time.type() != JSON_STRING)
      {
        // tm.increment("INVALID TYPE for created_at");
        return;
      }
      std::string timeString = time.as_string();
      struct tm t;
      if (!strptime(timeString.c_str(), "%Y-%m-%dT%H:%M:%SZ", &t))
      {
        std::cout<< "time conversion failed: " << timeString << std::endl;
        return;
      }
      time_t t2 = timegm(&t);
      
      // Find symbols array
      JSONNode::iterator symbolsIt = messageBody.find("symbols");
      if (symbolsIt == messageBody.end())
      {
        std::cout << "COULD NOT FIND symbols" << std::endl;
        continue;
      }
      
      std::stringstream ss;
      ss << "INSERT INTO stocktwits_minutes(symbol, start, user_id, count, sentiment) VALUES ";    
      bool first = true;      
      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())
        {
          // tm.increment("COULD NOT FIND symbol");
          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.
          // tm.increment("no stock_symbol");
          continue;
        }

        const std::vector<std::string> & symbols = explode(",", stockSymbolString);        
      
        // round to minute for db insert
        t2 = t2 / 60 * 60;
        
        for (std::vector<std::string>::const_iterator it = symbols.begin(); it != symbols.end(); ++it)
        {
          if (first)
            first = false;
          else
            ss << ',';
          ss << "(\"" << mysqlEscapeString(*it) << '"' << ", FROM_UNIXTIME(" << t2 << "), " << userId << ", 1, \"neutral\")";
        }    
      }
      if (!first)
      {
        ss << " ON DUPLICATE KEY UPDATE count = count + 1";
        //std::cout << ss.str();
        db.tryQueryUntilSuccess(ss.str());
      }
    }
    db.tryQueryUntilSuccess("UPDATE monitor_alive SET last_update = now() WHERE name = 'GetAllFromST'");
  }
  catch (std::invalid_argument ex)
  {
    std::cout << "EXCEPTION in parse" << std::endl;
    return;
  }
}

int main(int argc, char *argv[])
{
  addConfigItemsFromCommandLine(argv + 1);
  configItemsComplete();
  DatabaseWithRetry st("@st", "st");
  while (true)
  {
    checkForData(st);
    sleep(1);
  }
}