/////////////////////////////////////////////////////////////////////
// RodPixController.h
/////////////////////////////////////////////////////////////////////
//
// 08/04/03  Version 1.0 (PM)
//           Initial release
//

//! Class for the Pixel ROD

#ifndef _PIXLIB_RODPIXCONTROLLER
#define _PIXLIB_RODPIXCONTROLLER

#include "PixController.h"

#include <queue>

#ifndef NOTDAQ
namespace SctPixelRod {
  class RodPrimitive; 
  class RodModule;
  class RodOutList;
  class BocCard;
}
#endif

namespace PixLib {

class Bits;
class Config;

//! Pix Controller Exception class; an object of this type is thrown in case of a ROD error
class RodPixControllerExc : public PixControllerExc {
public:
  enum ErrorType{OK, BAD_SLOT_NUM, DMA_NOT_PERMITTED, TOO_MANY_MODULES, INVALID_MODID, NO_VME_INTERFACE,
                 ILLEGAL_HASHING_SCHEME, NON_UNIFORM_POINTS_NOT_IMPLEMENTED};
  //! Constructor
  RodPixControllerExc(ErrorType type, ErrorLevel el, std::string name, int info1, int info2) : 
    PixControllerExc(el, name), m_errorType(type), m_info1(info1), m_info2(info2) {}; 
  RodPixControllerExc(ErrorType type, ErrorLevel el, std::string name, int info1) : 
    PixControllerExc(el, name), m_errorType(type), m_info1(info1), m_info2(0) {}; 
  RodPixControllerExc(ErrorType type, ErrorLevel el, std::string name) : 
    PixControllerExc(el, name), m_errorType(type), m_info1(0), m_info2(0) {}; 

  //! Dump the error
  virtual void dump(std::ostream &out) {
    out << "Pixel Controller " << getCtrlName();
    out << " -- Type : " << dumpType();
    out << " -- Level : " << dumpLevel() << std::endl; 
  }
  //! m_errorType accessor
  ErrorType getErrorType() { return m_errorType; };
private:
  std::string dumpType() {
    std::string message;
    switch (m_errorType) {
    case OK : 
      return "No errors";
    case BAD_SLOT_NUM :
      std::ostringstream(message) <<  "Invalid ROD slot number (" << m_info1 << ")" ;
      return message;
    default :
      return "Uknown error";
    }
  }
  ErrorType m_errorType;
  int m_info1, m_info2;
};

class RodPixController : public PixController {
public:
  RodPixController(PixModuleGroup &modGrp, DBInquire *dbInquire);     //! Constructor
  RodPixController(PixModuleGroup &modGrp);                           //! Constructor
  virtual ~RodPixController();                                        //! Destructor
  virtual void initHW();                                              //! Hardware (re)init
  virtual void testHW();                                              //! Hardware test

  virtual void sendCommand(Bits commands, int moduleMask);                                    //! Send command no out
  virtual void sendCommandOutSync(Bits commands, int moduleMask, std::vector<Bits>& output);  //! Send command sync
  virtual void sendCommandOutAsync(Bits commands, int moduleMask, int commandID);             //! Send command async
  virtual bool checkOutReady(int commandID);                                                  //! Wait for command termination 
  virtual void getOutput(int commandID, std::vector<Bits>& output);                           //! Get command output
  virtual void writeModuleConfig(int moduleId, Module& config);                               //! Write module configuration 
  virtual void readModuleConfig(int moduleId, Module& config);                                //! Read module configuration 
  virtual void sendModuleConfig(unsigned int moduleMask);                                     //! Send module configuration
  virtual void sendPixel(unsigned int moduleMask){};                                          //! send specif. pixel register cfg.
  virtual void sendGlobal(unsigned int moduleMask){};                                         //! send specif. gloabal register cfg.
  virtual void sendPixel(unsigned int moduleMask, std::string regName, bool allDcsIdentical=false) {};  //! send pixel register cfg.
  virtual void sendPixel(unsigned int moduleMask, std::string regName, int DC){} ;  //! send pixel register cfg. for specific DC
  virtual void sendGlobal(unsigned int moduleMask, std::string regName){};                    //! send gloabal register cfg.

  virtual void setCalibrationMode();
  virtual void setConfigurationMode();
  virtual void setRunMode();

  virtual void writeScanConfig(PixScan &scn);                               //! Write scan parameters
  virtual void writeScanConfig(PixScanConfig &cfg);                         //! Write scan parameters
  virtual void startScan();                                                 //! Start a scan
  virtual bool fitHistos();                                                 //! Fit collected histograms
  virtual void getErrorHistos(unsigned int dsp, Histo* &his);               //! Read collected error arrays  
  virtual void getHisto(HistoType type, unsigned int xmod, unsigned 
                        int slv, std::vector< std::vector<Histo*> > &his);  //! Read an histogram
  virtual void getFitResults(HistoType type, unsigned int mod, 
                             unsigned int slv, std::vector< Histo * > &thr, 
                             std::vector< Histo * > &noise, 
                             std::vector< Histo * > &chi2);                 //! Read a Fit from Dsp
  virtual void writeRunConfig(PixRunConfig &cfg); //! Get the run configuration parameters from PixModuleGroup
  virtual void startRun(int ntrig = 0);           //! Start a run
  virtual void stopRun();                         //! Terminates a run
  virtual int runStatus();                        //! Check the status of the run
  virtual int nTrigger();                         //! Returns the number of trigger processed so far
  virtual bool moduleActive(int nmod) {           //! True if module is active during scan or run
    if (nmod>=0 && nmod<32) {
      for (unsigned int dsp=0; dsp<4; dsp++) {
	if (m_dspModMask[dsp] & (0x1<<nmod)) return true;
      } 
    }
    return false;
  }
  virtual void downloadFifo(int size);
  virtual bool getFifoBit(unsigned int ic, unsigned int il);
  virtual void prepareTestPattern(PixScan *scn);
  virtual void runTestPattern(PixScan *scn, std::vector< Histo* >&vh);

  virtual bool primitiveExists(std::string str);  //! Ask if a given primitive is implemented

  virtual void rodConfigure();
  virtual void setCalibrationDebugMode();
  virtual void setConfigurationDebugMode(); 
  virtual void setupTrapping(int slave, PixScan &scn);
  virtual void setupTrapping(int slave, PixScanConfig &cfg);
  virtual void setupTrapping(int slave, PixRunConfig &cfg);
  virtual void setupTrapping(int slave);
  virtual void startTrapping(int slave);
  virtual void stopTrapping(int slave);
  virtual void setupHistogramming(int slave, PixScan &scn);
  virtual void setupHistogramming(int slave, PixScanConfig &cfg);
  virtual void setupHistogramming(int slave, PixRunConfig &cfg);
  virtual void startHistogramming(int slave);
  virtual void stopHistogramming(int slave);
  virtual void stopScan();

  virtual void setGroupId(int module, int group);
  virtual void enableModuleReadout(int module);
  virtual void disableModuleReadout(int module, bool trigger);

  virtual void ledFlash(int period, int repet, int led);
  virtual void ledFlashSlave(int period, int repet, int slave);
  virtual void echo(Bits in, Bits out, unsigned int ndat);
  virtual void echoSlave(Bits in, Bits out, unsigned int ndat, int slave);
  virtual void testGlobalRegister(int module, int frontend);
  // new function for MonLeak and HitBusScaler
  virtual void shiftPixMask(int mask, int shift=1);

  void readMasterMem(int startAddr, int nWords, std::vector<unsigned int> &out);
  void writeMasterMem(int startAddr, int nWords, std::vector<unsigned int> &in);
  void readSlaveMem(int slaveId, int startAddr, int nWords, std::vector<unsigned int> &out) ;
  void writeSlaveMem(int slaveId, int startAddr, int nWords, std::vector<unsigned int> &in);
  void readSlaveMemDirect(int slaveId, int startAddr, int nWords, std::vector<unsigned int> &out);
  void writeSlaveMemDirect(int slaveId, int startAddr, int nWords, std::vector<unsigned int> &in);
  void readFifo(int fifo, int bank, int nWords, std::vector<unsigned int> &out);
  void writeFifo(int fifo, int bank, int nWords, std::vector<unsigned int> &in);
  void writeRegister(int regId, int offset, int size, unsigned int value);
  unsigned int readRegister(int regId, int offset, int size);

#ifndef NOTDAQ
  void executeMasterPrimitive(SctPixelRod::RodPrimitive &prim);
  void executeMasterPrimitiveSync(SctPixelRod::RodPrimitive &prim, std::vector<unsigned int> &out);
  void executeMasterPrimitiveSync(SctPixelRod::RodPrimitive &prim, SctPixelRod::RodOutList* &out);
  void executeMasterPrimitiveSync(SctPixelRod::RodPrimitive &prim);
  void executeSlavePrimitive(SctPixelRod::RodPrimitive &prim, int slave);
  void executeSlavePrimitiveSync(SctPixelRod::RodPrimitive &prim, std::vector<unsigned int> &out, int slave);
  void executeSlavePrimitiveSync(SctPixelRod::RodPrimitive &prim, SctPixelRod::RodOutList* &out, int slave);
  void executeSlavePrimitiveSync(SctPixelRod::RodPrimitive &prim, int slave);
  void executeSlavePrimitiveOnAll(SctPixelRod::RodPrimitive &prim);
  void executeSlavePrimitiveOnAllSync(SctPixelRod::RodPrimitive &prim);
  void executeSlavePrimitiveOnAllSync(SctPixelRod::RodPrimitive &prim, std::vector<unsigned int> &out);
  void executeSlavePrimitiveOnAllSync(SctPixelRod::RodPrimitive &prim, SctPixelRod::RodOutList* &out);

  void waitPrimitiveCompletion(std::vector<unsigned int> &out);
  void waitPrimitiveCompletion(SctPixelRod::RodOutList* &out);
  void waitPrimitiveCompletion();
#endif

  bool getErrBuffer(std::string &textBuf);
  bool getInfoBuffer(std::string &textBuf);
  bool getDiagBuffer(std::string &textBuf);
  bool getXferBuffer(std::string &textBuf);
  bool getGenericBuffer();

  void initBoc();              
  void getBocStatus();              
  void resetBoc();                
  void setBocRegister(std::string regtype, int channel, UINT32 value);
  void setBocRegister(std::string regtype, UINT32 value); 
  UINT32 getBocRegister(std::string type, int channel);  
  UINT32 getBocRegister(std::string type);              
  double getBocMonitorAdc(int channel);     
  void resetBocMonitorAdc();
#ifndef NOTDAQ
  SctPixelRod::RodModule *rodMod() { return m_rod; };  
#endif

private:
  virtual void configInit();         //! Init configuration structure
  
#ifndef NOTDAQ
  SctPixelRod::RodModule *m_rod;     //! Pointer to RodModule
#endif
  std::string m_ipramFile;           //! SDSP ipram file
  std::string m_idramFile;           //! SDSP idram file
  std::string m_extFile;             //! SDSP ext file
  int m_rodSlot;                     //! ROD Slot
  std::string m_mode;                //! ROD Operating Mode
  std::queue<std::string>m_textErr;  //! Copy of text err buffer
  std::queue<std::string>m_textInfo; //! Copy of text info buffer
  std::queue<std::string>m_textDiag; //! Copy of text diag buffer
  std::queue<std::string>m_textXfer; //! Copy of text xfer buffer
  long int m_hscanDataSize;          //! Size of the scan data structure
  long int* m_hscanData;             //! Scan data structure
  bool m_trapRunning[4];             //! Trapping active for SDSPs
  bool m_histoRunning[4];            //! Histogram task running on SDSPs
  unsigned int m_nMod;               //! Number of active modules
  unsigned int m_modNum[32];         //! Module id
  unsigned int m_modGrp[32];         //! Module group
  unsigned int m_modGrpDef[32];      //! Module group
  unsigned int m_modDCI[32];         //! DCI line for a module
  bool m_modActive[32];              //! Active flag for a module
  bool m_modTrigger[32];             //! Trigger flag for a module
  unsigned int m_dspModMask[4];      //! Modules being histogrammed by a SDSP
  unsigned int m_modMask;            //! Modules being read out
  int m_modPosition[32];             //! Position of a moduleId in the internal vectors
  unsigned int m_lsNbin;             //! Total number of bins during las scan
  bool m_scanActive;                 //! true if a scan is active
  bool m_runActive;                  //! true if a run is active
  bool m_fitDone;                    //! true if fit has been performed after a scan
  unsigned int m_fmtLinkMap[8];      //! Formatters link map
  ScanControl m_scanPar;             //! Scan configuration structure
                                     //! JW: defined in /RodDaq/CommonWithDSP/Pixel/scanControl_pxl.h

  Bits m_prepareSeq;                 //! Preparation sequence
  Bits m_executeSeq;                 //! Execution sequence
  Bits m_expectedOut;                //! Expected output pattern
  int m_inmLinkTable[96];            //! InLink usage table
  int m_inmModuleTable[96];          //| Module using InLink i
  std::vector<unsigned int> m_fifoA; //! InMem fifo A contetnt
  std::vector<unsigned int> m_fifoB; //! InMem fifo B conetent
};

}

#endif