// EdoId.cxx

#include "EdoId.h"
#include <iostream>
#include "FileId.h"
#include "EventId.h"
#include "EdoType.h"
#include "EdoKey.h"
#include "EdoTypeKey.h"

using std::ostream;
using hes::Index;
using hes::MAX_INDEX;
using hes::IndexVector;
using hes::FileId;
using hes::EventId;
using hes::EdoType;
using hes::EdoKey;
using hes::EdoTypeKey;
using hes::EdoId;

typedef vector<IndexVector> IdVector;

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

namespace {

// Vector of ID index vectors.
// This may change to a hash table.
IdVector IDVS;

// Empty vector.
const IndexVector EMPTY_VECTOR;

// Maximum value for the ID index.
Index MAX_VECTOR_INDEX = 0;

int initialize() {
  // Clear the vector.
  IDVS.clear();
  // Insert an invalid index vector in the first position.
  IDVS.push_back(IndexVector());
  // Assign MAX_INDEX.
  MAX_VECTOR_INDEX = MAX_INDEX;
  if ( MAX_VECTOR_INDEX > IDVS.max_size() ) {
    MAX_VECTOR_INDEX = IDVS.max_size();
  }
  // Test that the vector index range is less than the capacity of the vector.
  assert( MAX_VECTOR_INDEX <= IDVS.max_size() );
  // Test that the vector index range fits in Index.
  assert( MAX_VECTOR_INDEX <= MAX_INDEX );
  return 0;
}

// Force initialization.
int init = initialize();

// Find the matching entry in the table.
// Add a matching entry if it is not present.
Index find(const IndexVector& idxs) {
  Index idx = 0;
  for ( Index jdx=1; jdx<IDVS.size(); ++jdx ) {
    if ( IDVS[jdx] == idxs ) {
      idx = jdx;
      break;
    }
  }
  // Create the entry if it was not found.
  if ( idx == 0 ) {
    assert( IDVS.size() < MAX_VECTOR_INDEX );
    if ( IDVS.size() < MAX_VECTOR_INDEX ) {
      idx = IDVS.size();
      IDVS.push_back(idxs);
    }
  }
  return idx;
}
  
}  // end unnamed namespace

//**********************************************************************
// Static member functions.
//**********************************************************************

// Version.

Index EdoId::version() {
  assert( FileId::version() == 1 );
  assert( EventId::version() == 1 );
  assert( EdoType::version() == 1 );
  assert( EdoKey::version() == 1 );
  return 1;
}

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

// Number of allocated indices.

Index EdoId::id_count() {
  return IDVS.size() - 1;
}

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

// Max number of indices.

Index EdoId::max_id_count() {
  return MAX_VECTOR_INDEX;
}

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

// Default constructor.

EdoId::EdoId() : m_idx(0) { }

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

// Constructor from values.

EdoId::EdoId(FileId fid, EventId eid, EdoType typ, EdoKey key)
: m_idx(0) {
  // Exit if any of the arguments are invalid.
  if ( ! ( fid.is_valid() && eid.is_valid() &&
           typ.is_valid() && key.is_valid() ) ) {
    return;
  }
  // Construct the vector from the arguments.
  IndexVector idxs;
  idxs.push_back(fid.type_hi_index());
  idxs.push_back(fid.lo_index());
  idxs.push_back(eid.hi_index());
  idxs.push_back(eid.lo_index());
  idxs.push_back(typ.index());
  {
    const IndexVector& kidxs = key.indices();
    idxs.insert(idxs.end(), kidxs.begin(), kidxs.end() );
  }
  // Find the matching entry in the table.
  m_idx = find(idxs);
}
  
//**********************************************************************

// Constructor from indices.

EdoId::EdoId(const IndexVector& idxs) : m_idx(0) {
  // Find the matching entry in the table.
  m_idx = find(idxs);
}

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

// Constructor from an index vector iterator.

EdoId::EdoId(IndexVector::const_iterator& iidx, Index version)
: m_idx(0) {
  // Record the initial iterator.
  IndexVector::const_iterator iidx0 = iidx;
  // Read the file ID, event ID and type.
  if ( version == 1 ) {
    iidx += 5;
  } else {
    return;
  }
  IndexVector idxs;
  idxs.insert(idxs.end(), iidx0, iidx);
  assert( idxs.size() == 5 );
  // Read the key.
  // (More complicated because strings are variable length.)
  EdoKey key(iidx);
  if ( ! key.is_valid() ) {
    iidx = iidx0;
    return;
  }
  const IndexVector& key_idxs = key.indices();
  // Append the key indices to the others.
  idxs.insert(idxs.end(), key_idxs.begin(), key_idxs.end());
  // Find the matching entry in the table.
  m_idx = find(idxs);
}

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

// Validity check.

bool EdoId::is_valid() const {
  if ( m_idx == 0 ) {
    return false;
  }
  if ( m_idx >= IDVS.size() ) {
    return false;
  }
  if ( IDVS[m_idx].size() < 6 ) {
    return false;
  }
  Index keysize = IDVS[m_idx][5];
  keysize >>= 24;
  Index nwords = keysize/4 + 6;
  if ( IDVS[m_idx].size() != nwords ) {
    return false;
  }
  return true;
}

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

// Return the file ID.

FileId EdoId::file_id() const {
  if ( ! is_valid() ) {
    return FileId();
  }
  const IndexVector& idxs = IDVS[m_idx];
  return FileId(idxs[0], idxs[1]);
}

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

// Return the event ID.

EventId EdoId::event_id() const {
  if ( ! is_valid() ) {
    return EventId();
  }
  const IndexVector& idxs = IDVS[m_idx];
  return EventId(idxs[2], idxs[3]);
}

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

// Return the type.

EdoType EdoId::type() const {
  if ( ! is_valid() ) {
    return EdoType();
  }
  const IndexVector& idxs = IDVS[m_idx];
  return EdoType(idxs[4]);
}

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

// Return the key.

EdoKey EdoId::key() const {
  if ( ! is_valid() ) {
    return EdoKey();
  }
  const IndexVector& idxs = IDVS[m_idx];
  IndexVector::const_iterator iidx = idxs.begin() + 5;
  return EdoKey(iidx);
}

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

// Return the type and key.

EdoTypeKey EdoId::type_key() const {
  return EdoTypeKey(type(), key());
}

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

// Return the indices.

const IndexVector& EdoId::indices() const {
  if ( ! is_valid() ) {
    return EMPTY_VECTOR;
  }
  return IDVS[m_idx];
}

//**********************************************************************
// Free functions.
//**********************************************************************

// Equality.

bool operator==(const EdoId& lhs, const EdoId& rhs) {
  return lhs.indices() == rhs.indices();
}

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

// Inquality.

bool operator!=(const EdoId& lhs, const EdoId& rhs) {
  return ! (lhs == rhs);
}

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

// Output stream.
ostream& operator<<(ostream& lhs, const EdoId& rhs) {
  string sep = " ";
  lhs << rhs.file_id();
  lhs << sep;
  lhs << rhs.event_id();
  lhs << sep;
  lhs << rhs.type();
  lhs << sep;
  lhs << rhs.key();
  return lhs;
}

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