#include <iostream>

#include "MarketDataProxyClient.h"
#include "DataTypes.h"
#include "WireFormats.h"
#include "../fast_alert_search/history_server/Marshal.h"

#include "ClientInteractiveTest.h"


static void getTypeAndSymbol(DataTypes::Internal &type, std::string &symbol)
{
  std::cout<<"Select a type: ";
  // Internally we store a type as an integer.  When sending over the wire
  // we use well known strings to represent each type.  In this debug tool
  // we accept either.
  for (auto &kvp : DataTypes::KNOWN_TYPES)
  {
    std::cout<<' '<<(int)kvp.first<<' '<<kvp.second;
  }
  std::cout<<"?  ";
  std::string typeString;
  std::getline(std::cin, typeString);
  if (!std::cin) return;
  long typeAsNumber = strtolDefault(typeString, 0x7fffffff);
  if (typeAsNumber == (DataTypes::Internal)typeAsNumber)
    type = typeAsNumber;
  else
    type = DataTypes::fromString(typeString, false);
  std::cout<<"type = "<<(int)type<<" = "<<DataTypes::toString(type, false)
	   <<std::endl;
  std::cout<<"Symbol, empty string for all?  ";
  std::getline(std::cin, symbol);
}

static void showResponse(DataTypes::Internal type,
			 std::string const &symbol,
			 std::string const &data)
{
  std::cout<<"Response: type="<<DataTypes::toString(type, false)
	   <<", symbol=“"<<symbol<<"”, data=";
  try
  {
    if ((type == DataTypes::UNKNOWN) && symbol.empty() && data.empty())
      std::cout<<"disconnected";
    else if (type == DataTypes::LEVEL_1)
    {
      L1Data l1Data;
      if (!data.empty())
	unmarshal(data, l1Data);
      std::cout<<(std::string)l1Data.dump();
    }
    else if (type == DataTypes::TOS)
    {
      TosData tosData;
      if (!data.empty())
	unmarshal(data, tosData);
      std::cout<<(std::string)tosData.dump();
      if ((symbol=="$TIME") && (tosData.volume != 0))
	std::cout<<" -- "<<(tosData.newPrint?"Streaming":"Cached")
		 <<" data was delivered after "
		 <<(getMicroTime()-tosData.volume)<<"µs.";
    }
    else
      std::cout<<"“"<<data<<"”";
  }
  catch (MarshallingException const &ex)
  {
    std::cout<<"MarshallingException‼  "<<ex.what();
  }
  std::cout<<std::endl;
}

void clientInteractiveTest()
{
  MarketDataProxyClient &client = *MarketDataProxyClient::instance();
  client.setCallback(showResponse);
  while (std::cin)
  {
    std::cout<<"1) Subscribe."<<std::endl
	     <<"2) Unsubscribe."<<std::endl
	     <<"3) Request status."<<std::endl
	     <<"4) Remove listener."<<std::endl
	     <<"5) Restore listener."<<std::endl
	     <<"6) Quit."<<std::endl;
    std::string command;
    std::getline(std::cin, command);
    if (!std::cin) return;
    if (command == "1")
    { // Subscribe.
      DataTypes::Internal type;
      std::string symbol;
      getTypeAndSymbol(type, symbol);
      if (!std::cin) return;
      client.subscribe(type, symbol);
    }
    else if (command == "2")
    { // Unsubscribe.
      DataTypes::Internal type;
      std::string symbol;
      getTypeAndSymbol(type, symbol);
      if (!std::cin) return;
      client.unsubscribe(type, symbol);
    }
    else if (command == "3")
    { // Request status.
      class Listener : public ServerConnection64::IMessageListener
      {
      private:
	void output(std::string const &message,
			   int64_t clientId,
			   TalkWithServer64::MessageId messageId)
	{
	  std::cout<<"Status request.  clientId="<<clientId
		   <<", messageId="<<messageId<<", message="
		   <<std::endl<<message<<std::endl;
	}
      public:
	virtual void onMessage(std::string bytes,
			       int64_t clientId,
			       TalkWithServer64::MessageId messageId)
	{
	  output(bytes, clientId, messageId);
	}
	virtual void onAbort(int64_t clientId,
			     TalkWithServer64::MessageId messageId)
	{
	  output("Aborted‼", clientId, messageId);
	}
      };
      static Listener listener;
      static int64_t clientId = 0;
      std::cout<<"Sending status request.  clientId="<<clientId<<std::endl;
      client.requestStatus(&listener, clientId);
      clientId++;
    }
    else if (command == "4")
    { // Remove listener.
      client.clearCallback();
    }
    else if (command == "5")
    { // Restore listener.
      client.setCallback(showResponse);
    }
    else if (command == "6")
    { // Quit.
      return;
    }
    else
    {
      std::cout<<"Please select a number, 1-6"<<std::endl;
    }
  }
}