// SimpleCompoundDataset_t.cxx

#include "dataset_base/SimpleCompoundDataset.h"
#include <string>
#include <iostream>
#include <cassert>
#include <utility>
#include "dataset_util/FileName.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/DatasetCreator.h"
#include "dataset_base/DatasetRepository.h"
#include "dataset_base/Dataset_t.h"

using std::string;
using std::ostream;
using std::cout;
using std::endl;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::Dataset;
using dset::DatasetCreator;
using dset::DatasetRepository;
using dset::GenericDataset;
using dset::SimpleCompoundDataset;

void msg(const char* msg) {
  cout << "----- ";
  cout << msg;
  cout << " -----" << endl;
}

int SimpleCompoundDataset_t() {

  msg("Check promoter registration");
  assert( GenericDataset::has_promoter("SimpleCompoundDataset") );
  SimpleUniqueIdGenerator::set_as_default();

  msg("Create repository");
  SimpleUniqueIdGenerator::create_collection("Dataset", 123, 1001);
  assert( DatasetRepository::create_default_instance() == 0 );
  DatasetRepository& rep = DatasetRepository::default_instance();
  assert( rep.is_valid() );

  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("Empty");
  SimpleCompoundDataset dst0;
  cout << dst0 << endl;
  assert( dst0.is_valid() );
  assert( dst0.is_empty() );
  assert( dst0.location().is_empty() );
  assert( dst0.content().is_empty() );
  assert( ! dst0.is_locked() );

  msg("Check casts.");
  assert( dst0.is<SimpleCompoundDataset>() );
  assert( dst0.is<GenericDataset>() );
  assert( dst0.is<Dataset>() );

  msg("Construct empty dataset");
  SimpleCompoundDataset dst;
  cout << dst << endl;
  assert( dst.is_valid() );
  assert( dst.is_empty() );
  assert( ! dst.is_locked() );

  msg("Add datasets");
  {
    Dataset* ptds = new TestDataset;
    ptds->lock();
    cout << *ptds << endl;
    assert( rep.insert(ptds,true) == ptds->id() );
    assert( dst.merge(*ptds) == 0 );
  }
  {
    Dataset* ptds = new TestDataset;
    ptds->lock();
    assert( rep.insert(ptds,true) == ptds->id() );
    assert( dst.merge(*ptds) == 0 );
  }
  dst.lock();
  cout << dst << endl;
  assert( dst.is_valid() );
  assert( dst.is_locked() );
  assert( dst.constituent_ids().size() == 2 );
  assert( dst.constituents().size() == 2 );
  assert( is_valid(dst.constituents()) );
  assert( dst.content().is_valid() );
  assert( dst.content().is_empty() );
  assert( dst.location().is_valid() );

  msg("Clone");
  GenericDataset* pdst_clone = dst.clone();
  assert( pdst_clone != 0 );
  cout << *pdst_clone << endl;
  assert( pdst_clone->is_valid() );
  assert( pdst_clone->is<SimpleCompoundDataset>() );
  assert( pdst_clone->id() != dst.id() );
  assert( pdst_clone->parent() != 0 );
  assert( pdst_clone->parent() == &dst );
  assert( pdst_clone->parent()->id() == dst.id() );
  assert( pdst_clone->constituents() == dst.constituents() );
  assert( pdst_clone->content() == dst.content() );
  assert( pdst_clone->location() == dst.location() );

  msg("Write to XML");
  const XmlElement* pele = dst.xml();
  cout << *pele << endl;

  msg("Insert in DB");
  DatasetId id_db = rep.insert(&dst,false);
  assert( id_db == dst.id() );

  msg("Read XML");
  {
    const Dataset* pds = DatasetCreator::create(*pele, &rep);
    assert( pds != 0 );
    cout << *pds << endl;
    assert( pds->is_valid() );
    cout << *pds << endl;
    assert( pds->is<SimpleCompoundDataset>() );
    assert( pds->constituents() == dst.constituents() );
    assert( pds->content() == dst.content() );
    assert( pds->location() == dst.location() );
  }

  msg("All tests passed.");
  return 0;
}

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