#include "TrackingMods/SiDataRepCommand.hh"

#include "ErrorLogger_i/gERRLOG.hh"
#include "FrameUtil/AbsInterp.hh"

#include <iomanip>
#include <iostream>
#include <sstream>

SiDataRepCommand::SiDataRepCommand( const char* const theCommand,
               			    AppModule* theTarget,
               			    SiDataRep & dataRep,
				    SiDataRep::Scheme defaultScheme )
: APPCommand( theCommand, theTarget ),
  _dataRep( dataRep ),
  _paramList()
{
  _dataRep.setDataRep( defaultScheme );
}


void SiDataRepCommand::
     addSiLayerParam( SiLayerFinder::SiLayerFinderParam & param )
{
  _paramList.push_back( &param );
}


void SiDataRepCommand::_scaleParams()
{
  for ( std::vector<SiLayerFinder::SiLayerFinderParam*>::
        iterator i = _paramList.begin()
        ; i != _paramList.end() ; ++i )
  {
    (*i)->setScale( _dataRep.dataShift() );
  }
}


int SiDataRepCommand::handle( int argc, char* argv[] )
{
  if ( (argc < 2) || (argc > 3) )
  {
    ERRLOG( ELerror, "SiDataRepCommand" )
            << "Incorrect number of arguments.\n"
            << commandUsageString() << "\n"
            << endmsg;
    return AbsInterp::ERROR;
  }
  else
  {
    if ( strcmp( argv[1], "dump" ) == 0 )
    {
      std::cout << std::endl
           << _dataRep
	   << std::endl;
    }
    else if ( strcmp( argv[1], "set" ) == 0 )
    {
      const std::vector<std::string> & names   = _dataRep.validSchemeNameList();
      const std::vector<SiDataRep::Scheme> & schemes 
                                               = _dataRep.validSchemeList();
         
      for ( int i = 0 ; i < names.size() ; ++i )
      {
        if ( strcmp( argv[2], names[i].c_str() ) == 0 )
        {
          _dataRep.setDataRep( schemes[i] );
          _scaleParams();
          
	  return AbsInterp::OK;
        }
      }
      // If we get here, then an invalid data rep was chosen
      //
      ERRLOG( ELerror, "SiDataRepCommand" )
              << "Undefined data rep: \"" << argv[2] << "\"" 
	      << endmsg;
      return AbsInterp::ERROR;
    }
    else
    {
      ERRLOG( ELerror, "SiDataRepCommand" )
              << "Unknown command option:  "
	      << argv[1] << "\n"
	      << commandUsageString()
	      << endmsg;
      return AbsInterp::ERROR;
    }
  
    return AbsInterp::OK;
  }
  // return AbsInterp::OK;
}
  

void SiDataRepCommand::show() const
{
  std::cout << std::endl
       << "      "
       << "Current data rep is \"" 
       << _dataRep.validSchemeNameList()[_dataRep.currentDataRep()]
       << "\":  " 
       << _dataRep.validSchemeDescrList()[_dataRep.currentDataRep()]
       << std::endl
       << std::endl;
}


std::string SiDataRepCommand::commandUsageString() const
{
  return "Usage:  " + std::string( command() )
                    + " <set <data_rep>|dump>";
}


std::string SiDataRepCommand::description() const
{
  std::string retStr = "Set the data representation used to translate\n\
                        SIXD/ISLD banks\n\
                        Usage: " + std::string( command() ) + " dump -- print current rep\n\
                               " + std::string( command() ) + " set <data rep>\n\
                        <data rep> = \n";
  for ( int i = 0 ; i < _dataRep.validSchemeNameList().size() ; ++i )
  {
    std::ostringstream os;
    os << "\
                                     "
       << std::setw(15) << _dataRep.validSchemeNameList()[i] << ": "
       << _dataRep.validSchemeDescrList()[i] << std::endl;
       
    retStr += os.str();
  }                         
  return retStr;
}