// EventMergeDataset.cxx

#include "dataset_base/EventMergeDataset.h"
#include <string>
#include <iostream>
#include <memory>
#include "dataset_util/Environment.h"
#include "dataset_util/XmlElement.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_id/DatasetIdList.h"
#include "dataset_base/DatasetCreator.h"

using std::string;
using std::ostream;
using std::cerr;
using std::endl;
using std::auto_ptr;
using dset::Location;
using dset::Dataset;
using dset::DatasetList;
using dset::DatasetCreator;
using dset::GenericDataset;
using dset::EventMergeDataset;

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

namespace {

// Register creator.
int EventMergeDataset_xml_stat = GenericDataset::
  register_promoter("EventMergeDataset",
                    dset::promote<EventMergeDataset>);

}  // end unnamed namespace.

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

// Default constructor.

EventMergeDataset::EventMergeDataset() {
  set_fulltype("EventMergeDataset");
  set_id();
}

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

// Constructor for a new dataset.

EventMergeDataset::
EventMergeDataset(bool is_virtual, const Content& con) {
  set_fulltype("EventMergeDataset");
  set_id();
  if ( is_virtual ) {
    set_virtual();
  } else {
    set_location_composite();
  }
  set_evstate_first();
  if ( con.blocks().size() == 1 ) {
    const ContentBlock& block = con.blocks().front();
    if ( block.has_events() && !block.event_ids().size() ) {
      set_content(con);
      return;
    }
  }
  set_invalid();
  return;
}
  
//**********************************************************************

// Constructor from generic dataset.

EventMergeDataset::EventMergeDataset(const GenericDataset& gdst)
: GenericDataset(gdst) {
  if ( fulltype() != "EventMergeDataset" ) set_error(11);
}
  
//**********************************************************************

// Merge.

int EventMergeDataset::merge(const Dataset& dst, string) {
  // Check this dataset.
  if ( ! is_valid() ) return 1;
  if ( content().blocks().size() > 1 ) return 2;
  // Check the input dataset.
  if ( ! dst.id().is_global() ) return 14;
  if ( dst.content().has_nonevent_content() ) return 11;
  bool empty = false;
  if ( dst.content().is_empty() ) {
    empty = true;
    cerr << "EventMergeDataset::merge: Including empty dataset" << endl; 
  }
  if ( dst.content().blocks().size() != 1 ) return 13;
  const ContentBlock& newblock = dst.content().front();
  if ( ! dst.id().is_global() ) return 16;
  if ( ! empty ) {
    if ( newblock.content_ids().size() == 0 ) return 14;
    if ( newblock.event_count() == 0 ) return 15;
    // If we have defined the content ID's, make sure the new ones
    // are consistent and merge content.
    if ( content().blocks().size() == 1 ) {
      // Check location consistency.
      if ( is_virtual() && !dst.is_virtual() ) return 17;
      if ( !is_virtual() && dst.is_virtual() ) return 18;
      // Check merge.
      const ContentBlock& oldblock = content().front();
      if ( newblock.content_ids() != oldblock.content_ids() ) {
        string allow =
          Environment::current().value("DIAL_ALLOW_INCONSISTENT_CONTENT");
        if ( allow.size() ) {
          cerr << "EventMergeDataset::merge: Inconsistent content" << endl;
          cerr << "Unset DIAL_ALLOW_INCONSISTENT_CONTENT to disallow this"
               << endl;
        } else {
          cerr << "Set DIAL_ALLOW_INCONSISTENT_CONTENT to allow this" << endl;
          return 1000;
        }
      }
      int mstat = oldblock.check_merge(newblock);
      if ( mstat != 0 ) return 1000 + mstat;
      // Merge.
      mstat = merge_content(dst.content());
      if ( mstat != 0 ) return 2000 + mstat;
    // Otherwise use the content and location of input dataset to set the
    // values for this dataset.
    } else {
      int stat = set_content(dst.content());
      if ( stat != 0 ) return 3000 + stat;
      if ( dst.is_virtual() ) {
        stat = set_virtual();
      } else {
        stat = set_location_composite();
      }
      if ( stat ) {
        set_invalid();
        return 4000 + stat;
      }
    }
    assert( content().blocks().size() == 1 );
    if ( content().blocks().size() != 1 ) return 2999;
    if ( ! content().front().has_events() ) return 2998;
  }
  set_evstate_first();
  // Add the new dataset to the list of constituents.
  int astat = append_constituent(dst);
  if ( astat != 0 ) return 3000 + astat;
  return 0;
}

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