// GenericDataset_t.cxx

#include "dataset_base/GenericDataset.h"
#include <iostream>
#include "dataset_util/XmlElement.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_base/DatasetCreator.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"

using std::string;
using std::cout;
using std::endl;
using dset::Url;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::ContentBlock;
using dset::Content;
using dset::Location;
using dset::Dataset;
using dset::DatasetCreator;
using dset::GenericDataset;

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

// Class to test protected interface.
class TestGenericDataset : public GenericDataset {
public:
  TestGenericDataset(const Content& con, const Location& loc);
};

TestGenericDataset::
TestGenericDataset(const Content& con, const Location& loc) {
  assert( lock() != 0 );
  assert( set_fulltype("TestGenericDataset") == 0 );
  assert( set_id() == 0 );
  assert( set_id() != 0 );
  assert( set_content(con) == 0 );
  assert( set_content(con) != 0 );
  assert( set_location(loc) == 0 );
  assert( set_location(loc) != 0 );
  assert( set_evstate_none() == 0 );
}

// Promoter.
const GenericDataset* prom(const GenericDataset& gen) {
  return &gen;
}

int GenericDataset_t() {

  SimpleUniqueIdGenerator::create_collection("Dataset", 123, 1001);
  SimpleUniqueIdGenerator::set_as_default();

  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("Check type name");
  cout << GenericDataset::xml_name() << endl;
  assert( string(GenericDataset::xml_name()).size() );

  msg("Create content.");
  ContentIdList cids;
  cids.insert(ContentId("Test1", "key1"));
  cids.insert(ContentId("Test2", "key2"));
  cids.insert(ContentId("Test3", "key3"));
  ContentBlock cb1("NoEventDataset", "no-events", cids);
  EventIdList eids;
  eids.insert(EventIdRange(1001, 9500, 9599));
  ContentBlock cb2("EventDataset", "events", cids, eids);
  Content con1;
  con1.merge(cb1);
  con1.merge(cb2);
  cout << con1 << endl;
  assert( con1.blocks().size() == 2 );
  assert( ! con1.is_empty() );

  msg("Create location");
  Location loc1;
  system("touch myfile1.dat");
  loc1.files().push_back(Url("file:myfile1.dat"));
  cout << loc1 << endl;
  assert( ! loc1.is_empty() );

  msg("Create default dataset");
  GenericDataset gd1;
  cout << gd1 << endl;
  assert( gd1.fulltype() == "" );
  assert( gd1.is_valid() );
  assert( gd1.is_empty() );
  assert( ! gd1.id().is_valid() );
  assert( ! gd1.parent_id().is_valid() );
  assert( gd1.parent() == 0 );
  assert( ! gd1.is_locked() );
  assert( gd1.content().is_empty() );
  assert( ! gd1.is_virtual() );
  assert( gd1.location().is_empty() );
  assert( gd1.constituent_ids().size() == 0 );
  assert( gd1.constituents().size() == 0 );
  assert( gd1.clone() == 0 );
  assert( gd1.xml() == 0 );
  assert( gd1.select(con1) != 0 );
  assert( gd1.owner() == "me" );
  assert( gd1.create_time() > 0 );

  msg("Set ID");
  DatasetId id1(123, 1);
  DatasetId id2(123, 2);
  DatasetId id3(123, 3);
  assert( gd1.set_id(id1) == 0 );
  cout << gd1 << endl;
  assert( gd1.is_valid() );
  assert( gd1.id() == id1 );

  msg("Attempt to reset ID");
  assert( gd1.set_id(id2) != 0 );
  cout << gd1 << endl;
  assert( gd1.is_valid() );
  assert( gd1.id() == id1 );

  msg("Set parent ID");
  assert( gd1.set_parent_id(id2) == 0 );
  cout << gd1 << endl;
  assert( gd1.is_valid() );
  assert( gd1.parent_id() == id2 );

  msg("Attempt to reset ID");
  assert( gd1.set_id(id3) != 0 );
  cout << gd1 << endl;
  assert( gd1.is_valid() );
  assert( gd1.parent_id() == id2 );

  msg("Create test dataset");
  TestGenericDataset gd2(con1, loc1);
  assert( gd2.lock() == 0 );
  cout << gd2 << endl;
  assert( gd2.is_valid() );
  assert( ! gd2.is_empty() );
  assert( gd2.id().is_valid() );
  assert( ! gd2.parent_id().is_valid() );
  assert( ! gd2.is_virtual() );
  assert( ! gd2.location().is_empty() );
  assert( gd2.constituent_ids().size() == 0 );
  assert( gd2.constituents().size() == 0 );

  msg("Clone");
  GenericDataset* pd3 = gd2.clone();
  assert( pd3 != 0 );
  cout << *pd3 << endl;
  assert( pd3->is_valid() );
  assert( ! pd3->is_locked() );
  assert( pd3->id().is_valid() );
  assert( pd3->parent_id() == gd2.id() );

  msg("Set attributes and lock");
  assert( pd3->lock() == 0 );
  cout << *pd3 << endl;

  msg("Fetch XML");
  const XmlElement* pxd3 = pd3->xml();
  assert( pxd3 != 0 );
  cout << *pxd3 << endl;
  assert( gd1.select(con1) != 0 );

  msg("Construct from XML");
  GenericDataset gd4(*pxd3);
  cout << gd4 << endl;
  assert( gd4.is_valid() );
  assert( gd4.id() == pd3->id() );
  assert( gd4.parent_id() == pd3->parent_id() );
  assert( gd4.content() == pd3->content() );
  assert( gd4.location() == pd3->location() );
  assert( gd4.owner() == "me" );
  assert( gd4.create_time() > 0 );

  msg("Create virtual dataset");
  GenericDataset gd5(con1, "MyVirtualDataset");
  cout << gd5 << endl;
  assert( gd5.is_valid() );
  assert( gd5.fulltype() == "MyVirtualDataset" );
  assert( gd5.id().is_valid() );
  assert( gd5.is_virtual() );
  assert( gd5.content() == con1 );

  msg("Promoters");
  GenericDataset::NameList::size_type nprom =
    GenericDataset::promoters().size();
  assert( ! GenericDataset::has_promoter("TestGenericDataset") );
  assert( GenericDataset::promote(gd2) == 0 );
  assert( GenericDataset::register_promoter("TestGenericDataset", prom) == 0 );
  assert( GenericDataset::has_promoter("TestGenericDataset") );
  assert( GenericDataset::promote(gd2) == &gd2 );
  assert( GenericDataset::promoters().size() == nprom+1 );

  msg("Invalid dataset");
  GenericDataset baddst(true);
  assert( ! baddst.is_valid() );
  assert( baddst.is_locked() );
  GenericDataset baddst2(false);
  assert( ! baddst2.is_valid() );
  assert( ! baddst2.is_locked() );

  msg("Size");
  size_t mem = gd2.memsize();
  cout << "memsize = " << mem << endl;
  assert( mem > 100 );
  
  return 0;
}

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