#include <fstream>
#include <math.h>

#include "../../shared/SimpleLogFile.h"
#include "../misc_framework/GenericDataNodes.h"
#include "../data_framework/SynchronizedTimers.h"
#include "../data_framework/GenericTosData.h"
#include "../data_framework/SimpleMarketData.h"
#include "../data_framework/TradeDirection.h"
#include "ReportAlertsThread.h"
#include "TiqMisc.h"

#include "ArthurIlyayev.h"


class ArthurIlyayevAlert : public DataNode
{
private:
  std::string _symbol;
  TradeDirection _direction;
  double _previousClose;
  BarCounter *_barCounterData;
  GenericTosDataNode *_tosData;

  bool _primed;
  double _threashold;
  void onTos();
  void onBarCounter();
  static bool goodRange(double high, double low);
  enum { wTOS, wBarCounter };
  void onWakeup(int msgId);

  ArthurIlyayevAlert(DataNodeArgument const &args);
  friend class DataNode;

public:
  static DataNodeLink *find(std::string const &symbol, bool up)
  {
    ArthurIlyayevAlert *node;
    return findHelper(NULL, 0, node, argList(symbol, up));
  }
};

ArthurIlyayevAlert::ArthurIlyayevAlert(DataNodeArgument const &args) :
  _primed(false)
{
  DataNodeArgumentVector const &argList = args.getListValue();
  assert(argList.size() == 2);  // Symbol, Long
  _symbol = argList[0].getStringValue();
  _direction = argList[1].getBooleanValue();
  _previousClose = getPreviousClose(_symbol);
  if (_previousClose)
    {
      addAutoLink(GenericTosDataNode::find(this, wTOS, _tosData, _symbol));
      addAutoLink(BarCounter::find(this, wBarCounter, _barCounterData, 5));
    }
}

bool ArthurIlyayevAlert::goodRange(double high, double low)
{ // The spec was not specific about what price to use.
  const double price = (high + low) / 2;
  const double min = (price < 80.0)?0.10:0.20;
  const double max = floor(price / 10.0) / 10.0 + 0.09;
  const double range = high - low;
  return (range >= min) && (range <= max);
}

void ArthurIlyayevAlert::onTos()
{
  if (!_tosData->getValid())
    return;
  const double price = _tosData->getLast().price;
  if (price <= 0)
    return;
  if (_direction.moreReportable(price, _threashold))
    {
      _primed = false;
      std::string info = "symbol=";
      info += urlEncode(_symbol);
      info += "&last=";
      info += urlEncode(formatPrice(price));
      info += "&prev_close=";
      info += urlEncode(formatPrice(_previousClose));
      info += "&time=";
      info += formatTime(time(NULL));
      std::string category =
	_direction.isLong()?"ArthurIlyayev-Up":"ArthurIlyayev-Down";
      ReportAlertsThread::getInstance()->reportAlert(category, info);
    }
}

void ArthurIlyayevAlert::onBarCounter()
{
  if (_barCounterData->getTimePhase() != BarCounter::tpNotify)
    // Only update once per candle transition.
    return;
  if (_barCounterData->getCurrentBar() != 1)
    return;
  // This is the end of the first bar.
  if (!_tosData->getValid())
    return;
  const double open = _tosData->getLast().open;
  if (open <= 0)
    return;
  const double gap = (open - _previousClose) / _previousClose * 100.0;
  if (!_direction.upByAtLeast(gap, 0.5))
    return;
  const Integer volume = _tosData->getLast().volume;
  if (volume < 20000)
    return;
  const double high = _tosData->getLast().high;
  const double low = _tosData->getLast().low;
  if (!goodRange(high, low))
    return;
  _threashold = _direction.mostReportable(high, low);
  _primed = true;
}

void ArthurIlyayevAlert::onWakeup(int msgId)
{
  switch (msgId)
    {
    case wTOS:
      if (_primed)
	onTos();
      break;
    case wBarCounter:
      onBarCounter();
      break;
    }
}


/////////////////////////////////////////////////////////////////////
// Global
/////////////////////////////////////////////////////////////////////

static std::vector< DataNodeLink * > cleanup;

static void alertsForSymbol(std::string const &symbol)
{
  TclList msg;
  msg<<FLF<<symbol;
  sendToLogFile(msg);
  cleanup.push_back(ArthurIlyayevAlert::find(symbol, true));
  cleanup.push_back(ArthurIlyayevAlert::find(symbol, false));
}

static void alertsForList(std::string const &fileName)
{
  TclList msg;
  msg<<FLF<<fileName;
  sendToLogFile(msg);
  std::ifstream stream(fileName.c_str(), std::ios_base::in);
  while(stream)
    {
      std::string symbol;
      std::getline(stream, symbol);
      symbol = strtoupper(trim(symbol, " \r"));
      if (!symbol.empty())
        alertsForSymbol(symbol);
    }
}

void initArthurIlyayevAlerts()
{
  alertsForList("data/ArthurIlyayev_symbols.txt");
}

/////////////////////////////////////////////////////////////////////
// Requirements
/////////////////////////////////////////////////////////////////////

/*

From: arthur ilyayev [mailto:arthur.ilyayev@gmail.com] 
Sent: Thursday, May 24, 2012 11:42 AM
To: brad@trade-ideas.com
Subject: Arthur, we spoke earlier about a custom filter
 
Hi Brad,

 Pleasure to speak with you earlier.  About the filter, I need to construct a filter gap up/gap down. 

 

A)     Min gap has to be .5 % up and down, ( calculate the % gap using the previous day close and 1st print at 9:30am)

B)      Also, the filter has to show only specified ranges of the 1st 5 min bar with specified prices of stocks, this range will be set in the 1st 5 min bar.  (table of prices and ranges shown below)

C)      Minimum volume of the 1st 5 min bar  has to be at least 20,000 or more

D)     Filter out only NSYE, AMEX and Nasdaq stocks.

E)      The filter has to show breaking out of the 1st 5 min bar going with the gap.. ex. If a stock gapped up then I want to see a breaking out of the range making new highs, and if a stock gapped down then I want to see the breaking down out of the specified ranges making new lows.

 
Price of Stock
 range of 1st 5 min bar
 
show these ranges only
                               minimum
 maximum
 10-19.99
                                         0.10
          0.19
 20-20.99
                                         0.10
          0.29
 30-30.99
                                         0.10
          0.39
 40-49.99
                                         0.10
          0.49
 50-59.99
                                         0.10
          0.59
 60-69.99
                                         0.10
          0.69
 70-79.99
                                         0.10
          0.79
 80-89.99
                                         0.20
          0.89
 90-99.99
                                         0.20
          0.99
 100-109.99
                                         0.20
          1.09
 110-119.99
                                         0.20
          1.19
 120-129.99
                                         0.20
          1.29
 130-139.99
                                         0.20
          1.39
 140-149.99
                                         0.20
          1.49


 */