// SimpleDatasetMerger.cxx

#include "dataset_split/SimpleDatasetMerger.h"
#include <iostream>
#include "dataset_base/DatasetRepository.h"
#include "dataset_base/SimpleCompoundDataset.h"

using std::string;
using std::ostream;
using std::auto_ptr;
using dset::Dataset;
using dset::DatasetList;
using dset::DatasetRepository;
using dset::DatasetMerger;
using dset::SimpleDatasetMerger;
using dset::DatasetMergeResult;

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

// Constructor.

SimpleDatasetMerger::SimpleDatasetMerger()
: m_pdst(new SimpleCompoundDataset), m_pdst_last(0), m_open(true) { }

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

// Destructor..

SimpleDatasetMerger::~SimpleDatasetMerger() {
  delete m_pdst;
}

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

// Validity.

bool SimpleDatasetMerger::is_valid() const {
   return true;
}

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

// Open.

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

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

// Append a dataset.

int SimpleDatasetMerger::append(const Dataset& dst) {
  if ( m_pdst == 0 ) return 1;
  if ( ! is_open() ) return 2;
  if ( ! m_pdst->is_valid() ) return 3;
  std::cout << "SDM append: id before merging :" << m_pdst->id() << std::endl;
  m_pdst->merge(dst);
  std::cout << "SDM append: id after merging : " << m_pdst->id() << std::endl;
  m_pdst_last = 0;
  if ( ! m_pdst->is_valid() ) return 4;
  return 0;
}

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

// Return the result.

DatasetMergeResult SimpleDatasetMerger::result() {
  if ( m_pdst == 0 ) {
    return DatasetMergeResult(101);
  }
  if ( ! m_pdst->is_valid() ) {
    return DatasetMergeResult(103);
  }
  // If we do not have a locked version equivalent to the current
  // dataset, then make one.
  std::cout << "SDM Before locking id = " << m_pdst->id() << std::endl; 
  if ( m_pdst_last == 0 ) {
    // Fetch dataset repository.
    DatasetRepository& rep = DatasetRepository::default_instance();
    if ( ! rep.is_valid() ) {
      return DatasetMergeResult(104);
    }
    // Clone to make new dataset for merging.
    int ilock =  m_pdst->lock();
    std::cout << "SDM: Return value after lock : " << ilock << std::endl;  
    Dataset* pclone = m_pdst->clone();
    if ( pclone == 0 ) {
      return DatasetMergeResult(105);
    }
    if ( ! pclone->is<SimpleCompoundDataset>() ) {
      delete pclone;
      return DatasetMergeResult(106);
    }
    pclone->set_parent_id(DatasetId());
    
    std::cout << "SDM: Id of m_pdst = " << m_pdst->id() << std::endl  ;
    
    m_pdst_last = m_pdst;
 
    std::cout << "SDM: Id of m_pdst_last = " << m_pdst_last->id() << std::endl ;
    
    m_pdst = dynamic_cast<SimpleCompoundDataset*>(pclone);
    if ( m_pdst == 0 ) {
      delete pclone;
      return DatasetMergeResult(107);
    }
    // Put locked dataset in repository.
    DatasetId did = rep.insert(m_pdst_last, true);
    
    std::cout << "SDM: Id of dataset being inserted = " << m_pdst_last->id() << std::endl;
    std::cout << "SDM: Inside SimpleDatasetMerger ... error encounterd while insert = " << rep.error() << std::endl; 
    
    if ( ! did.is_valid() ) {
      delete m_pdst_last;
      m_pdst_last = 0;
      return DatasetMergeResult(108);
    }
  }
  // Construct result from original dataset.
  const DatasetList& idsts = m_pdst->constituents();
  const DatasetList& mdsts = m_pdst->constituents();
  const DatasetList rdsts;
  return DatasetMergeResult(idsts, mdsts, rdsts, m_pdst_last);
}

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

// Close.

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

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

// Output stream.

ostream& SimpleDatasetMerger::ostr(std::ostream& str) const {
  if ( ! is_valid() ) {
    str << "Invalid simple dataset merger";
  } else {
    int count = m_pdst->constituents().size();
    str << "Simple dataset merger includes " << count << " dataset";
    if ( count != 1 ) str << "s";
  }
  return str;
}

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