#include "../../shared/SimpleLogFile.h"
#include "../../shared/ReplyToClient.h"

#include "GenericHaltData.h"

////////////////////////////////////////////////////////////////////
// HaltData
////////////////////////////////////////////////////////////////////

void HaltData::clear()
{
  time = 0;
  type = 0;
  reason = 0;
  price = 0.0;
}

TclList HaltData::dump() const
{
  TclList out;  
  out<<"time"<<time<<"type"<<type<<"reason"<<reason<<"price"<<price;
  return out;
}

////////////////////////////////////////////////////////////////////
// GenericHaltDataNode
////////////////////////////////////////////////////////////////////

const std::string debugPrefix = "GenericHaltDataNode.debug.";

GenericHaltDataNode::GenericHaltDataNode(DataNodeArgument const &args) :
  _symbol(args.getStringValue())
{
  _last.clear();
  registerForBroadcast(debugPrefix + _symbol, bmDebug);
  TclList msg;
  msg << "GenericHaltDataNode constructor" << _symbol;
  sendToLogFile(msg);
}

DataNodeLink *GenericHaltDataNode::find(DataNodeListener *listener, int msgId,
				       GenericHaltDataNode *&node,
				       std::string const &symbol)
{
  if (implementation)
    { // Captured by a real data feed.
      return implementation(listener, msgId, node, symbol);
    }
  // Use the default, which only presents debug messages.
  return findHelper(listener, msgId, node, symbol);
}

Debugger *GenericHaltDataNode::debugger = NULL;

void GenericHaltDataNode::registerDebugger(DataNodeManager *manager)
{ // This class doesn't make any real attempt to deal with multiple calls to
  // this function.  Presumably if you try to start this twice, the command
  // handler will complain about a duplicate command name being registered.
  // If it was important, we could get around that limitation by taking the
  // command name as an imput to this function.
  debugger = new Debugger("debug_halt", bmDebug, debugPrefix, manager);
}

void GenericHaltDataNode::onBroadcast(BroadcastMessage &message, int msgId)
{
  switch (msgId)
    {
    case bmDebug:
      {
        DebugMessage const &m = dynamic_cast< DebugMessage const & >(message);
	//sendToLogFile(TclList()<<FLF<<p);
	//const bool set = getPropertyDefault(p, "set") == "1";
	//if (set)
	//  {
	//	  _last.halt = getProperty(p, std::string("halt"), _last.halt);
	//  }
	TclList msg;
	msg<<FLF<<_last.reason
	   <<ctimeString(getSubmitTime());
	if (m.getSocketInfo())
	  addToOutputQueue(m.getSocketInfo(), msg, m.getResponseMessageId());
	//else if (!set)
	//  sendToLogFile(msg);
	//if (set)
	  notifyListeners();
      }
    }
}

HaltImplementation GenericHaltDataNode::implementation = NULL;

void GenericHaltDataNode::registerImplementation
(HaltImplementation newImplementation)
{
  implementation = newImplementation;
}