// DefaultDatasetMerger.cxx

#include "dataset_split/DefaultDatasetMerger.h"
#include <iostream>
#include "dataset_base/SimpleCompoundDataset.h"
#include "dataset_base/EventMergeDataset.h"
#include "dataset_split/DatasetMergeResult.h"

using std::string;
using std::ostream;
using std::auto_ptr;
using dset::Dataset;
using dset::DatasetList;
using dset::SimpleCompoundDataset;
using dset::EventMergeDataset;
using dset::DatasetMergeResult;
using dset::DefaultDatasetMerger;

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

// Constructor.

DefaultDatasetMerger::DefaultDatasetMerger(string dir)
: m_dir(dir), m_err(0), m_pdst(0), m_pdstres(0),
  m_pres(0), m_open(true) {
  const DatasetList empty;
  m_pres = new DatasetMergeResult(empty, empty, empty, 0);
}

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

// Destructor.

DefaultDatasetMerger::~DefaultDatasetMerger() {
  delete m_pdst;
  delete m_pdstres;
  delete m_pres;
}

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

// Validity.

bool DefaultDatasetMerger::is_valid() const {
  return m_pdst == 0 || m_pdst->is_valid();
}

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

// Open.

bool DefaultDatasetMerger::is_open() const {
  return is_valid() && m_open;
}

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

// Append.

int DefaultDatasetMerger::append(const Dataset& dst) {
  if ( ! is_valid() ) return 201;
  if ( ! is_open() ) return 202;
  // First call clone the input dataset to create the merged datset.
  if ( m_pdst == 0 ) {
    // Special handing for TextDataset.
    if ( dst.fulltype() == "TextDataset" ) {
      m_pdst = new SimpleCompoundDataset;
      int mstat = m_pdst->merge(dst);
      if ( mstat ) {
        return set_error(211);
      }
    // Special handling for event datasets except ApecDataset.
    // We require simple content for now.
    } else if ( dst.is_event_dataset() &&
                dst.fulltype() != "ApecDataset" ) {
      const Content& con = dst.content();
      if ( con.size() != 1 ) {
        return set_error(221);
      }
      const ContentBlock& blk = con.front();
      EventIdList eids;
      Content newcon(blk.dataset_type(), blk.name(),
                     blk.content_ids(), eids);
      m_pdst = new EventMergeDataset(dst.is_virtual(), newcon);
      int mstat = m_pdst->merge(dst);
      if ( mstat ) {
        return set_error(222);
      }
    // Otherwise clone the input dataset.
    } else {
      m_pdst = dst.clone(m_dir);
      if ( m_pdst == 0 ) return set_error(203);
      if ( ! m_pdst->is_valid() ) return set_error(204);
    }
    m_pdst->set_parent_id(DatasetId());
  // Other calls, append to the merged dataset.
  } else {
    if ( ! m_pdst->is_valid() ) return set_error(205);
    int stat = m_pdst->merge(dst, m_dir);
    if ( stat != 0 ) return set_error(2000 + stat);
  }
  delete m_pres;
  m_pres = 0;
  m_dsts.push_back(&dst);
  dst.release();
  return set_error(0);
}
  
//**********************************************************************

// Return the result.

DatasetMergeResult DefaultDatasetMerger::result() {
  if ( error() ) {
    return DatasetMergeResult(error());
  }
  if ( ! is_open() ) {
    return *m_pres;
  }
  if ( m_pdst == 0 ) {
    return *m_pres;
  }
  if ( ! m_pdst->is_valid() ) {
    return DatasetMergeResult(set_error(212));
  }
  // If we do not have a result, then make one.
  if ( m_pres == 0 ) {
    // Clone to make new merged dataset.
    m_pdst->lock();
    const DatasetList rdsts;
    delete m_pdstres;
    m_pdstres = m_pdst;
    m_pres = new DatasetMergeResult(m_dsts, m_dsts, rdsts, m_pdstres);
    m_pdst = m_pdst->clone(m_dir);
    if ( m_pdst == 0 ) {
      return DatasetMergeResult(set_error(214));
    }
    m_pdst->set_parent_id(DatasetId());
  }
  return *m_pres;
}

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

// Close.

int DefaultDatasetMerger::close() {
  // Delete the open dataset.
  delete m_pdst;
  m_pdst = 0;
  // Release the result dataset.
  if ( m_pdstres != 0 ) {
    m_pdstres->release();
  }
  // Mark result closed.
  m_open = false;
  return 0;
}

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

// Set error code.

int DefaultDatasetMerger::set_error(int err) {
  m_err = err;
  return err;
}

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

// Return the error code.

int DefaultDatasetMerger::error() const {
  return m_err;
}

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

// Output stream.

ostream& DefaultDatasetMerger::ostr(std::ostream& str) const {
  if ( ! is_valid() ) {
    str << "Invalid default dataset merger";
  } else {
    int count = m_dsts.size();
    str << "Default dataset merger with " << count << " datasets";
    if ( count != 1 ) str << "s";
  }
  return str;
}

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