// EventIdRange.cxx

#include "dataset_id/EventIdRange.h"
#include <iostream>
#include "dataset_util/XmlElement.h"
#include "dataset_util/DtdRegistry.h"

using std::ostream;

typedef EventIdRange::size_type size_type;
typedef EventId::RunNumber RunNumber;
typedef EventId::EventNumber EventNumber;

//**********************************************************************
// Local definitions.
//**********************************************************************

namespace {

// Register the DTD.
DtdRegistry::Status ISTAT =
  DtdRegistry::register_dtd<EventIdRange>("dataset");

}  // end unnamed namespace

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

// DTD.

const Text& EventIdRange::dtd() {
  static Text txt;
  if ( txt.size() == 0 ) {
    txt.append("<!ELEMENT EventIdRange EMPTY>");
    txt.append("<!ATTLIST EventIdRange");
    txt.append("  run   CDATA #REQUIRED");
    txt.append("  first CDATA #REQUIRED");
    txt.append("  last  CDATA #REQUIRED");
    txt.append(">");
  }
  return txt;
}

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

// Default constructor.

EventIdRange::EventIdRange() : _id(EventId()), _size(0) { }

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

// Constructor.

EventIdRange::EventIdRange(EventId id, size_type size)
: _id(id), _size(size) { }

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

// Full constructor from run and event numbers.

EventIdRange::
EventIdRange(RunNumber run, EventNumber evt1, EventNumber evt2) {
  EventNumber e1 = evt1;
  EventNumber e2 = evt2;
  if ( e1 > e2 ) {
    e1 = evt2;
    e2 = evt1;
  }
  _id = EventId(run, e1);
  _size = e2 - e1 + 1;
}

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

// XML constructor.

EventIdRange::EventIdRange(const XmlElement& ele) {
  assert( ele.name() == xml_name() );
  if ( ele.name() == xml_name() ) {
    if ( ele.has_attribute("run") &&
         ele.has_attribute("first") &&
         ele.has_attribute("last") ) {
      int errcount = ele.error_count();
      RunNumber run = ele.attribute_as_int("run");
      EventNumber e1 = ele.attribute_as_int("first");
      EventNumber e2 = ele.attribute_as_int("last");
      assert( errcount == ele.error_count() );
      if ( errcount == ele.error_count() ) {
        if ( e1 > e2 ) {
          e1 = e2;
          e2 = e1;
        }
        _id = EventId(run, e1);
	_size = e2 - e1 + 1;
      }
    }
  }
}

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

// Contains another range.

bool EventIdRange::contains(const EventIdRange& rng) const {
  return rng.run() == run() &&
         rng.first_event() >= first_event() &&
	 rng.last_event() <= last_event();
}

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

// Write XML.

const XmlElement* EventIdRange::xml() const {
  XmlElement* pele = new XmlElement(xml_name());
  pele->add_attribute_as_int("run", run());
  pele->add_attribute_as_int("first", first_event());
  pele->add_attribute_as_int("last", last_event());
  return pele;
}

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

// Remove the first event.

void EventIdRange::pop_front() {
  if ( is_valid() ) {
    _id = EventId( run(), first_event()+1 );
    --_size;
  }
}

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

// Remove the last event.

void EventIdRange::pop_back() {
  if ( is_valid() ) {
    --_size;
  }
}

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

// Ordering.
// Ranges may not overlap and are not adjacent.

bool operator<(const EventIdRange& lhs, const EventIdRange& rhs) {
  if ( lhs.run() < rhs.run() ) return true;
  if ( rhs.run() < lhs.run() ) return false;
  return lhs.last_event()+1 < rhs.first_event();
}

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

// Equality.

bool operator==(const EventIdRange& lhs, const EventIdRange& rhs) {
  return lhs.run() == rhs.run() &&
         lhs.first_event() == rhs.first_event() &&
         lhs.last_event() == rhs.last_event();
}

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

// Inequality.

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

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

// Output stream.

ostream& operator<<(ostream& lhs, const EventIdRange& rhs) {
  if ( rhs.is_valid() ) {
    lhs << "run " << rhs.run() << " event";
    if ( rhs.size() == 1 ) {
      lhs << " " << rhs.first_event();
    } else {
      lhs << "s " << rhs.first_event() << "-"
       << rhs.last_event();
    }
  } else {
    lhs << "invalid event range";
  }
  return lhs;
}

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