// CompoundDatasetMerger_t.cxx

#include "dataset_split/CompoundDatasetMerger.h"
#include <string>
#include <iostream>
#include "dataset_util/getcwd.h"
#include "dataset_util/Environment.h"
#include "dataset_util/XmlElement.h"
#include "dataset_util/DtdRegistry.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/SimpleCompoundDataset.h"
#include "dataset_base/DatasetRepository.h"

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

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;
}

// Make a compound dataset.
Dataset* make_dataset() {
  DatasetRepository& dr = DatasetRepository::default_instance();
  ContentIdList cids1;
  ContentIdList cids2;
  ContentIdList cids3;
  Content con1("Type1", "name1", cids1);
  Content con2("Type2", "name2", cids2);
  Content con3("Type3", "name3", cids3);
  Dataset* pdst1 = new TestDataset(con1);
  pdst1->lock();
  cout << *pdst1 << endl;
  assert( dr.insert(pdst1).is_valid() );
  Dataset* pdst2 = new TestDataset(con1);
  pdst2->lock();
  assert( dr.insert(pdst2).is_valid() );
  Dataset* pdst3 = new TestDataset(con3);
  pdst3->lock();
  assert( dr.insert(pdst3).is_valid() );
  Dataset* pdst = new SimpleCompoundDataset;
  pdst->merge(*pdst1);
  pdst->merge(*pdst2);
  pdst->merge(*pdst3);
  pdst->lock();
  assert( dr.insert(pdst).is_valid() );
  return pdst;
}

int CompoundDatasetMerger_t() {

  system("rm -rf dr.dat resolver.dat 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");
  Dataset* pdst1 = make_dataset();
  cout << *pdst1 << endl;
  assert( pdst1->constituents().size() == 3 );

  msg("Create dataset 2");
  Dataset* pdst2 = make_dataset();
  cout << *pdst2 << endl;

  msg("Create dataset 3");
  Dataset* pdst3 = make_dataset();
  cout << *pdst3 << endl;

  msg("Create merger");
  CompoundDatasetMerger merger(getcwd());
  cout << merger << endl;

  msg("Merge datasets");
  assert( merger.append(*pdst1) == 0 );
  assert( merger.append(*pdst2) == 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 );
  DatasetId did = pdst->id();
  cout << *pdst << endl;
  assert( pdst->is_valid() );
  assert( pdst->is_locked() );
  assert( pdst->constituents().size() == 3 );
  assert( res.dataset() == pdst );
  msg("Constituents");
  DatasetId did1 = pdst->constituents().front()->id();
  for ( DatasetList::const_iterator idst=pdst->constituents().begin();
        idst!=pdst->constituents().end(); ++idst ) {
    cout << **idst << endl;
  }

  msg("Merge another dataset");
  assert( merger.append(*pdst3) == 0 );
  cout << merger << endl;
  res = merger.result();
  assert( res.merged_datasets().size() == 3 );
  const Dataset* pdstm2 = res.dataset();
  assert( pdstm2 != 0 );
  cout << *pdstm2 << endl;
  assert( pdstm2->id() != did );
  msg("Constituents");
  for ( DatasetList::const_iterator idst=pdstm2->constituents().begin();
        idst!=pdstm2->constituents().end(); ++idst ) {
    cout << **idst << endl;
  }
  assert( pdstm2->constituents().front()->id() != did1 );

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

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

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