// SimpleDatasetMerger_t.cxx

#include "dataset_split/SimpleDatasetMerger.h"
#include <string>
#include <iostream>
#include "dataset_util/Environment.h"
#include "dataset_util/XmlElement.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_base/DatasetRepository.h"
#include "dataset_base/SimpleCompoundDataset.h"

using std::string;
using std::cout;
using std::endl;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::DatasetList;
using dset::Dataset;
using dset::SimpleCompoundDataset;
using dset::DatasetMergeResult;
using dset::DatasetMerger;
using dset::DatasetRepository;
using dset::SimpleDatasetMerger;

void msg(string txt) {
  cout << "*** ";
  cout << txt;
  cout << " ***" << endl;
}

bool check(int value, int expect =0) {
  if ( value != expect ) {
    cout << "Expected " << expect << "; found " << value << endl;
  }
  return value == expect;
}

int SimpleDatasetMerger_t() {

  system("rm -rf UniqueId");
  SimpleUniqueIdGenerator::create_collection("Dataset", 123, 1001);
  SimpleUniqueIdGenerator::set_as_default();

  msg("Create test DR");
  assert( DatasetRepository::create_default_instance() == 0 );

  msg("Fetch default instance of CSC.");
  assert( CredentialSelectionCatalog::create_default_instance() == 0 );
  CredentialSelectionCatalog& sc =
    CredentialSelectionCatalog::default_instance();
  cout << sc << endl;
  assert( sc.is_valid() );
  string owner = "me";
  assert( GssCredentialManager::set_default() == 0 );
  assert( GssCredentialManager::set_owner("me") == 0 );

  msg("Create dataset 1");
  TestDataset dst1;
  dst1.lock();
  cout << dst1 << endl;

  msg("Create dataset 2");
  TestDataset dst2;
  dst2.lock();
  cout << dst2 << endl;

  msg("Create dataset 3");
  TestDataset dst3;
  dst3.lock();
  cout << dst3 << endl;

  msg("Create merger");
  SimpleDatasetMerger merger;
  cout << merger << endl;
  assert( merger.is_open() );

  msg("Merge datasets");
  assert( merger.append(dst1) == 0 );
  assert( merger.append(dst2) == 0 );
  cout << merger << endl;
  assert( merger.is_valid() );

  msg("Fetch result");
  DatasetMergeResult res = merger.result();
  cout << res << endl;
  assert( res.is_valid() );
  assert( res.input_datasets().size() == 2 );
  assert( res.merged_datasets().size() == 2 );
  assert( res.rejected_datasets().size() == 0 );
  const Dataset* pdst = res.dataset();
  assert( pdst != 0 );
  assert( pdst->is_valid() );
  assert( pdst->is_locked() );
  assert( res.dataset() == pdst );
  assert( pdst->is<SimpleCompoundDataset>() );
  const SimpleCompoundDataset& cdst =
    pdst->cast<SimpleCompoundDataset>();
  assert( cdst.constituents().size() == 2 );

  msg("Merge another dataset");
  assert( merger.append(dst3) == 0 );
  cout << merger << endl;
  res = merger.result();
  assert( res.merged_datasets().size() == 3 );
  assert( res.dataset() != pdst );
  assert( res.dataset() != 0 );

  msg("Close");
  assert( merger.close() == 0 );
  assert( ! merger.is_open() );

  msg("Testing complete");
  return 0;
}

#ifdef CTEST_MAIN
int main() {
  return SimpleDatasetMerger_t();
}
#endif