#include "SimpleLogFile.h"

#include "ThreadMonitor.h"


/////////////////////////////////////////////////////////////////////
// ThreadMonitor::LongestTime::Helper
/////////////////////////////////////////////////////////////////////

std::string ThreadMonitor::LongestTime::Helper::getInfoForThreadMonitor()
{
  if (_longest.empty())
    return "";
  TclList result;
  for (std::map< std::string, Info >::const_iterator it = _longest.begin();
       it != _longest.end();
       it++)
  {
    TclList item;
    item<<it->first                              // Name
	<<it->second.longest
	<<(it->second.total / it->second.count)  // Average
	<<it->second.count;
    result<<item;
  }
  _longest.clear();
  return TclList()<<"longest"<<result;
}

ThreadMonitor::LongestTime::Helper::Helper()
{
  ThreadMonitor::find().add(this);
}

ThreadMonitor::LongestTime::Helper &ThreadMonitor::LongestTime::Helper::find()
{
  static __thread Helper *instance = NULL;
  if (!instance)
    instance = new Helper;
  return *instance;
}

void ThreadMonitor::LongestTime::Helper::report(std::string const &name, 
						TimeVal::Microseconds time)
{
  Info &info = _longest[name];
  if (time > info.longest)
    info.longest = time;
  info.total += time;
  info.count++;
}


/////////////////////////////////////////////////////////////////////
// ThreadMonitor::LongestTime
/////////////////////////////////////////////////////////////////////

ThreadMonitor::LongestTime::LongestTime(std::string const &name) : 
  _name(name), _start(true) { }

ThreadMonitor::LongestTime::~LongestTime()
{
  const TimeVal stop(true);
  const TimeVal::Microseconds elapsed = 
    stop.asMicroseconds() - _start.asMicroseconds();
  Helper::find().report(_name, elapsed);
}


/////////////////////////////////////////////////////////////////////
// ThreadMonitor
/////////////////////////////////////////////////////////////////////

// This and related functions lets you get the CPU usage for a thread.
// http://linux.die.net/man/3/pthread_getcpuclockid  That would be nice to
// report.  Currently we only report clock time.  I had looked at CPU time in
// the past, but I was only aware of the times system call, and that gives you
// CPU time for the entire process.

ThreadMonitor::ThreadMonitor() :
  _lastOutput(TimeVal(true).asMicroseconds()),
  _stateStart(_lastOutput),
  _currentState("working")
{
}

static __thread ThreadMonitor *monitor = NULL;

ThreadMonitor &ThreadMonitor::find()
{
  if (!monitor)
    {
      monitor = new ThreadMonitor;
    }
  return *monitor;
}

void ThreadMonitor::setState(std::string const &state)
{
  TimeVal::Microseconds now = TimeVal(true).asMicroseconds();
  bool needToDump = ((now - _lastOutput) > 300000000LL);
  if (needToDump || (state != _currentState))
    {
      _timeInState[_currentState] += (now - _stateStart);
      _stateStart = now;
      _currentState = state;
    }
  if (needToDump)
    {
      TimeVal::Microseconds totalTime = now - _lastOutput;
      TclList message;
      message<<"ThreadMonitor.C"
	     <<_name
	     <<"total_time"
	     <<dtoa(totalTime / 1000000.0, 4);
      typedef std::set< std::pair< TimeVal::Microseconds, std::string > > SS;
      SS sortedStates;
      for (std::map< std::string, TimeVal::Microseconds >::const_iterator it =
             _timeInState.begin();
           it != _timeInState.end();
           it++)
	sortedStates.insert(std::make_pair(it->second, it->first));
      TclList states;
      for (SS::reverse_iterator it = sortedStates.rbegin(); 
	   it != sortedStates.rend(); 
	   it++)
	{
	  states<<it->second
		<<(dtoa(it->first * 100.0 / totalTime, 4) + "%");
	}
      message<<"states"
	     <<states;
      if (_counters.size())
	{
	  TclList counters;
	  for (std::map< std::string, unsigned int >::iterator it =
		 _counters.begin();
	       it != _counters.end();
	       it++)
	    {
	      counters<<it->first
		      <<it->second;
	    }
	  message<<"counters"
		 <<counters;
	}
      for (std::set< Extra * >::iterator it = _extras.begin(); 
	   it != _extras.end();
	   it++)
      {
	std::string forLog = (*it)->getInfoForThreadMonitor();
	if (!forLog.empty())
	  message<<forLog;
      }
      _timeInState.clear();
      _counters.clear();
      _lastOutput = now;
      sendToLogFile(message);
    }
}

void ThreadMonitor::increment(std::string const &counter, int by)
{
  if (!by)
    // The point of using by is that it is sometimes much faster.
    // This optimization keeps it from ever significantly slowing things down.
    return;  
  setState(_currentState);
  _counters[counter] += by;
}