#include <iostream>
#include <unordered_set>
#include <map>

#include "../shared/GlobalConfigFile.h"
#include "../shared/DatabaseWithRetry.h"
#include "../shared/DatabaseForThread.h"
#include "../shared/MiscSQL.h"
#include "../ax_alert_server/Types.h"
#include "DataFormat.h"
#include "AutoSecondaryData.h"
#include "FieldLists.h"
#include "Strategy.h"

/* This is an interactive way to test the alerts.  You can enter a collaborate
 * string and a list of alerts to grab from the database and watch the code
 * run.
 *
 * To run this test:
 *  ./fast_alert_search -f ../../live_server/config_common.txt -i port_number=1234 -i test_specific_alerts=1
 */


// Find in database, convert to record, return as a vector, no side effects.
// getAlerts() adds "SELECT ... WHERE ", and the caller provides the rest of
// the SQL.
static std::vector< RecordRef > getAlerts(std::string const &sql2)
{
  static const auto fields = DatabaseFieldInfo::getAlertFields();
  static const std::string sql1 = "SELECT "
    + DatabaseFieldInfo::makeSqlFieldList(fields)
    + " FROM alerts WHERE ";
  const std::string sql = sql1 + sql2;
  std::vector< Record::Ref > result;
  MysqlResultRef fromDatabase =
    DatabaseForThread(DatabaseWithRetry::SLAVE)->tryQueryUntilSuccess(sql);
  result.reserve(fromDatabase->numRows());
  for (; fromDatabase->rowIsValid(); fromDatabase->nextRow())
    result.push_back(DatabaseFieldInfo::makeRecord(fromDatabase, fields));
  return result;
}

// Internally (i.e. most of the C++ code) we only deal with collaborate strings
// that start with "O=" or similar.  The GUI is responsible for removing
// "http://...?" part, if it exists.  But there is no GUI for this test!
static std::string stripURL(std::string collaborate)
{
  const auto pieces = explode("?", collaborate);
  assert(pieces.size() < 3);
  // pieces.size() == 1 means no ?, use it all as is.
  // pieces.size() == 2 means a normal URL, grab the part after the ?
  // pieces.size() > 2 means more than one ?.  Which is never valid.  The ? is
  // a special character and should be quoted.  If we see it here it's some
  // type of mistake.
  return pieces[pieces.size() - 1];
}

static void doTestSpecificAlertsNow()
{
  DatabaseWithRetry &database = *DatabaseForThread(DatabaseWithRetry::SLAVE);
  
  UserId userId = 4;
  std::string collaborate;
  std::unordered_set< std::string > dates;
  std::map< int64_t, RecordRef > alerts;  // id => alert

  // Find in database, load them into our list, show feedback to the user.
  // addAlerts() adds "SELECT ... WHERE ", and the caller provides the rest of
  // the SQL.
  const auto addAlerts = [&](std::string const &sql) {
    const auto newAlerts = getAlerts(sql);
    std::cout<<"Loaded:  ";
    if (newAlerts.empty())
      std::cout<<"none";
    else
      for (RecordRef const &alert : newAlerts)
      {
	int64_t id = alert->lookUpValue(MainFields::id).getInt();
	alerts[id] = alert;
	std::cout<<id<<' ';
	const int64_t timestamp =
	  alert->lookUpValue(MainFields::timestamp).getInt();
	const std::string date = dateToMysql(timestamp, false);
	if (dates.insert(date).second)
	{ // First time we've seen this date.
	  AutoSecondaryData &asd = AutoSecondaryData::instance();
	  asd.addAlertsDaily(date);
	  asd.notifyWhenReady([date]() {
	      std::cout<<" [alerts_daily for "<<date<<" is ready] "
		       <<std::flush;
	    });
	}
      }
    std::cout<<std::endl;
  };
  
  const auto showHelp = [&]() {
    std::cout<<"u: Set user id.  (Current = "<<userId<<')'<<std::endl
    <<"i: Add alerts by id."<<std::endl
    <<"t: Add alerts by type."<<std::endl
    <<"r: Remove alert.  (Current count "<<alerts.size()<<")"<<std::endl
    <<"s: Set collaborate string.  ";
    if (collaborate.empty())
      std::cout<<"(Currently empty.)";
    else
    {
      AlertConfig config;
      config.load(collaborate, userId, database,
		  /* allowCustomColumns = */ true,
		  /* allowNonFilterColumns = */ true);
      if (config.getWindowName().empty())
	std::cout<<"(Currently unnamed.)";
      else
	std::cout<<"(Currently “"<<config.getWindowName()<<"”.)";
    }
    std::cout<<std::endl
    <<"g: Go.  Test the strategy aginst the alerts."<<std::endl
    <<"q: Quit.  Done with this test."<<std::endl;
  };

  showHelp();
  bool done = false;
  while (!done)
  {
    std::string line;
    std::getline(std::cin, line);
    if (!std::cin)
      break;
    if (line.length() != 1)
      showHelp();
    else
      switch (line[0])
      {
      case 'u': // Set user id.
	{
	  std::cout<<"New user id? ";
	  std::getline(std::cin, line);
	  const int64_t newValue = strtolDefault(line, -1);
	  if (newValue < 0)
	    std::cout<<"Invalid user id."<<std::endl;
	  else
	  {
	    std::cout<<"Changing userId from "<<userId<<" to "<<newValue<<std::endl;
	    userId = newValue;
	  }
	  break;
	}
      case 'i': // Add alerts by id.
	{
	  std::cout<<"Give one or more ids separated by commas."
		   <<std::endl<<"?  ";
	  std::getline(std::cin, line);
	  // Sanitize the input.  In PHP we used a regular expression.  We
	  // want a list of positive integers separate by commas, nothing else.
	  const auto pieces = explode(",", line);
	  std::string sql;
	  bool failed = false;
	  for (std::string const &piece : pieces)
	  {
	    const int64_t id = strtolDefault(piece, -1);
	    if (id < 1)
	    {
	      std::cout<<"Invalid alert id:  “"<<piece<<"”."<<std::endl;
	      failed = true;
	    }
	    else
	    {
	      if (!sql.empty())
		sql += ',';
	      sql += ntoa(id);
	    }
	  }
	  if (!failed)
	    addAlerts("id IN (" + sql + ")");
	  break;
	}
      case 't': // Add alerts by type.
	{
	  std::cout<<"Alert type?  "<<std::endl;
	  std::getline(std::cin, line);
	  addAlerts("alert_type = '" + mysqlEscapeString(line)
		    + "' ORDER BY id DESC LIMIT 5");
	  break;
	}
      case 'r': // Remove alert.
	{
	  std::cout<<"Alert id? ";
          std::getline(std::cin, line);
          const int64_t id = strtolDefault(line, -1);
          if (id < 0)
            std::cout<<"Invalid alert id."<<std::endl;
          else if (alerts.erase(id))
	    std::cout<<"Removed."<<std::endl;
	  else
	    std::cout<<"Not found."<<std::endl;
	  break;
	}
      case 's': // Set collaborate string.
	std::cout<<"Collaborate string? ";
	std::getline(std::cin, collaborate);
	collaborate = stripURL(collaborate);
	break;
      case 'g': // Go.  Test the strategy aginst the alerts.
	{
	  Parse::AlertStrategy alertStrategy;
	  alertStrategy.load(collaborate, userId, database,
			     /* compile= */ true);
	  for (auto const &kvp : alerts)
	  {
	    Execution::RecordInfo recordInfo;
	    recordInfo.setRecord(kvp.second);
	    alertStrategy.init(recordInfo);
	    const bool match = alertStrategy.evaluateWhere(recordInfo);
	    std::cout<<"Alert with id "<<kvp.first<<" "
		     <<(match?"matches":"does NOT match")
		     <<" query."<<std::endl;			
	  }
	  break;
	}
      case 'q': // Quit.  Done with this test.
	std::cout<<"Bye!"<<std::endl;
	done = true;
	break;
      default:
	showHelp();
	break;
      }
  }
}

void optionallyTestSpecificAlerts()
{ // getConfigItem:  test_specific_alerts=1 will run a test harness.  These
  // getConfigItem:  are interactive tests.  You will be prompted with
  // getConfigItem:  instructions and you can guide the test.  You need to
  // getConfigItem:  specify a slave database on the command line.  During the
  // getConfigItem:  test you can grab alerts from the database by specifying
  // getConfigItem:  the alert's id number.
  if (getConfigItem("test_specific_alerts") == "1")
    doTestSpecificAlertsNow();
}