// CbntDataset.cxx

#include "dataset_CBNT/CbntDataset.h"
#include <vector>
#include <iostream>
#include <memory>
#include "dataset_util/XmlElement.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_base/DatasetCreator.h"
#include "dataset_CBNT/HbookFile.h"

using std::string;
using std::vector;
using std::ostream;
using std::cout;
using std::endl;
using std::auto_ptr;
using dset::Url;
using dset::Location;
using dset::Dataset;
using dset::DatasetCreator;
using dset::GenericDataset;
using dset::CbntDataset;

//**********************************************************************
// Local data.
//**********************************************************************

namespace {

// For debugging.
int verbose = 0;

// HBOOK directory names.
string NTDIR = "CBNT";
string PWDIR = " ";

// Temporary registration of content index.
// This should eventually move to ContentId.
ContentId NO_KEY_ID =
  ContentId::register_id(311, CbntDataset::content_id_name());

}  // end unnamed namespace

//**********************************************************************
// FORTRAN declarations.
//**********************************************************************

extern "C" {

// Initialize HBOOK (and zebra and paw).
int pawin_();

// Directory listing.
void hldir_(const char* path, const char* opt, int lpath, int lopt);

// Change directory.
void hcdir_(const char* path, const char* opt, int lpath, int lopt);

// Read into memory.
void hrin_(int* id, int* cycle, int* offset);

// hexist
bool hexist_(int* id);

// Print ntuple properties.
void hprnt_(int* id);

// Fetch ntuple blocks
//void hbloks_(int* id);
void hbloks_(const int* id, const int* maxnam, int* nnam, char bnames[][8]);

// Description of the variables in a row.
void hbname_(int* id, const char* bname, int* address, char* form);
void evids_(int* id, int* nevt, int* runs, int* evts);

}  // end extern "C"

//**********************************************************************
// Helper functions.
//**********************************************************************

namespace {

//**********************************************************************

// HBOOK directory listing.

void hldir(string path, string opt) {
  hldir_(path.c_str(), opt.c_str(), path.size(), opt.size());
}

//**********************************************************************

// HBOOK directory change.

void hcdir(string path, string opt ="") {
  hcdir_(path.c_str(), opt.c_str(), path.size(), opt.size());
}

//**********************************************************************

// Return the block names in an ntuple.

typedef vector<string> StringList;
unsigned int hbloks(int id, StringList& bnames) {
  bnames.erase(bnames.begin(), bnames.end());
  const int maxblk = 1000;
  int nblk = maxblk;
  char cbnames[maxblk][8];
  hbloks_(&id, &maxblk, &nblk, cbnames);
  if ( nblk > maxblk ) nblk = maxblk;
  for ( int iblk=0; iblk<nblk; ++iblk ) {
    char cname[9];
    for ( int i=0; i<9; ++ i ) cname[i] = 0;
    strncpy(cname, cbnames[iblk], 8);
    string name = cname;
    string::size_type send = name.size();
    while ( name[send-1] == ' ' ) --send;
    name = name.substr(0, send);
    bnames.push_back(name);
  }
  if ( int(bnames.size()) != nblk ) {
    return 0;
  }
  return bnames.size();
}

//**********************************************************************

// Register promoter
int CbntDataset_xml_stat = GenericDataset::
  register_promoter("CbntDataset", dset::promote<CbntDataset>);

//**********************************************************************

}  // end unnamed namespace

//**********************************************************************
// Member functions.
//**********************************************************************

// Constructor from file.

CbntDataset::CbntDataset(Url file, bool locked)
: m_have_evflags(false), m_file(file), m_phfile(0) {
  if ( ! m_file.is_valid() ) {
    set_error(11);
    return;
  }
  // Set full type.
  set_fulltype("CbntDataset");
  // Set ID's.
  set_id();
  // Set the location.
  Location loc;
  loc.files().push_back(file);
  if ( set_location(loc) != 0 ) {
    set_error(12);
    return;
  }
  assert( location().files().size() == 1 );
  // Open the tuple.
  int ostat = hbook_file().open();
  if ( ostat != 0 ) {
    set_error(1000 + ostat);
    return;
  }
  // Set directory.
  if ( verbose > 5 ) {
    cout << "Starting directory" << endl;
    hldir(PWDIR, "T");
    cout << "Change directory" << endl;
  }
  hcdir(NTDIR);
  if ( verbose > 5 ) {
    cout << "Final directory" << endl;
    hldir(PWDIR, "T");
  }
  // Fetch the ntuple block names.
  int id = 3333;
  int cycle = 999999;
  int offset = 0;
  hrin_(&id, &cycle, &offset);
  if ( ! hexist_(&id) ) {
    set_error(31); 
    return;
  }
  StringList bnames;
  int nblk = hbloks(id, bnames);
  if ( nblk == 0 ) {
    set_error(32);
    return;
  }
  if ( verbose > 6 ) {
    cout << "# blocks = " << nblk << endl;
    for ( int iblk=0; iblk<nblk; ++iblk ) {
      cout << "  --" << bnames[iblk] << "--" << endl;
    }
  }
  // Fetch content ID's.
  ContentIdList cids;
  for ( int iblk=0; iblk!=nblk; ++iblk ) {
    ContentId cid(content_id_name(), bnames[iblk]);
    if ( ! cid.is_valid() ) {
      set_error(41);
      return;
    }
    cids.insert(cid);
  }
  // Fetch the event ID's.
  EventIdList eids;
  const int maxevt = 10000;
  int nevt = maxevt;
  int runs[maxevt];
  int evts[maxevt];
  evids_(&id, &nevt, runs, evts);
  if ( nevt < 0 ) {
    set_error(50);
    return;
  }
  if ( nevt == 0 ) {
    set_error(51);
    return;
  }
  if ( nevt >= maxevt ) {
    set_error(52);
    return;
  }
  for (int ievt=0; ievt<nevt; ++ievt) {
    EventId eid(runs[ievt], evts[ievt]);
    if ( ! eid.is_valid() ) {
      set_error(53);
      return;
    }
    eids.insert(eid);
    if ( int(eids.size()) != ievt+1 ) {
      set_error(54);
      return;
    }
  }
  if ( int(eids.size()) != nevt ) {
    set_error(55);
    return;
  }
  // Close the file
  hbook_file().close();
  // Set the content.
  Content con("CbntDataset", "CBNT", cids, eids);
  if ( set_content(con) != 0 ) {
    set_error(60);
    return;
  }
  assert( con.size() == 1 );
  set_evstate_first();
  // Set lock status.
  if ( locked ) lock();
}

//**********************************************************************

// Generic dataset constructor.

CbntDataset::CbntDataset(const GenericDataset& gdst)
: GenericDataset(gdst), m_have_evflags(false),
  m_phfile(0) {
  // OK if input dataset is of the same type.
  if ( fulltype() == "CbntDataset" ) {
    assert( content_storage_state() == EXPLICIT );
    assert( location_storage_state() == EXPLICIT );
    assert( location().files().size() == 1 );
    return;
  }
  set_error(70);
  return;
}

//**********************************************************************

// Copy constructor.

CbntDataset::CbntDataset(const CbntDataset& rhs)
: GenericDataset(rhs),
  m_have_evflags(rhs.m_have_evflags), m_evflags(rhs.m_evflags),
  m_file(rhs.m_file), m_phfile(0) { }

//**********************************************************************

// Destructor.

CbntDataset::~CbntDataset() {
  delete m_phfile;
}

//**********************************************************************

// Logical file.

Url CbntDataset::file() const {
  if ( ! m_file.is_valid() ) {
    assert( location().files().size() == 1 );
    Url file = location().files().front();
    m_file = file;
  }
  return m_file;
}

//**********************************************************************

// Filename.

string CbntDataset::filename() const {
  return file().fullpath();
}

//**********************************************************************

// HBOOK file.

HbookFile& CbntDataset::hbook_file() const {
  static HbookFile bad_hfile;
  if ( ! is_valid() ) return  bad_hfile;
  if ( m_phfile == 0 ) {
    HbookFile* phbfile = new HbookFile(filename());
    if ( ! is_valid() ) {
      delete phbfile;
      return bad_hfile;
    }
    m_phfile = phbfile;
  }
  return *m_phfile;
}

//**********************************************************************

// Return the event flags.

const CbntDataset::FlagList& CbntDataset::event_flags() const {
  if ( ! is_valid() ) return m_evflags;
  // Build list if it is not up to date.
  if ( ! m_have_evflags ) {
    m_evflags.clear();
    EventIdList eids = content().front().event_ids();
    assert( hbook_file().is_valid() );
    bool open = hbook_file().is_open();
    if ( ! open ) hbook_file().open();
    // Fetch the event ID list.
    int id = 3333;
    assert( id != 0 );
    const int maxent = 1000;
    int nent = maxent;
    int runs[maxent];
    int evts[maxent];
    evids_(&id, &nent, runs, evts);
    assert( nent < maxent );
    hbook_file().close();
    // Set size.
    m_evflags.resize(nent);
    // Fill.
    for (int ient=0; ient<nent; ++ient) {
      EventId eid(runs[ient], evts[ient]);
      m_evflags[ient] = eids.contains(eid);
    }
    if ( ! open ) hbook_file().close();
    m_have_evflags = true;
  }
  return m_evflags;
}

//**********************************************************************

// Select.

int CbntDataset::select(const Content&) {
  //m_have_evflags = false;
  return 1;
}

//**********************************************************************