// VirtualEventDataset_t.cxx

#include "dataset_base/VirtualEventDataset.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/Dataset_t.h"

using std::string;
using std::ostream;
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;
using dset::VirtualEventDataset;

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

int VirtualEventDataset_t() {

  msg("Check promoter registration");
  assert( GenericDataset::has_promoter("VirtualEventDataset") );

  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("Create content ID's");
  string cname = "TestContent";
  ContentId cid = ContentId::register_id(221, cname.c_str());
  ContentId cid1(cname, "first");
  ContentId cid2(cname, "second");
  cout << cid1 << endl;
  cout << cid2 << endl;

  msg("Create content ID list");
  ContentIdList cids;
  cids.insert(ContentId(cid1));
  cids.insert(ContentId(cid2));
  cout << cids << endl;

  msg("Create event ID list");
  EventIdList eids;
  eids.insert(EventId(101,11));
  eids.insert(EventId(101,12));
  eids.insert(EventId(101,13));
  eids.insert(EventId(101,14));
  eids.insert(EventId(101,15));

  msg("Create content");
  Content con;
  ContentBlock cb1("VirtualEventDataset", "events", cids, eids);
  con.push_back(cb1);
  cout << con << endl;

  msg("Construct dataset from content");
  VirtualEventDataset dst(con);
  cout << dst << endl;
  assert( dst.is_valid() );
  assert( dst.is_virtual() );
  assert( ! dst.is_empty() );
  assert( ! dst.is_locked() );
  assert( dst.content() == con );

  msg("Check casts.");
  assert( dst.is<VirtualEventDataset>() );
  assert( dst.is<Dataset>() );

  msg("Bad merge");
  ContentBlock cb0("NoDataset", "noevents", cids);
  Content con0;
  con0.push_back(cb0);
  GenericDataset bdst(con0);
  bdst.lock();
  assert( bdst.is_valid() );
  assert( dst.merge(bdst) != 0 );

  msg("Merge");
  EventIdList eids2;
  eids2.insert(EventId(101,21));
  eids2.insert(EventId(101,22));
  Content con2;
  ContentBlock cb2("VirtualEventDataset", "events", cids, eids2);
  con2.push_back(cb2);
  VirtualEventDataset dst2(con2);
  dst2.lock();
  cout << dst2 << endl;
  assert( dst2.is_valid() );
  assert( dst2.content() == con2 );
  assert( dst.merge(dst2) == 0 );
  cout << dst << endl;
  assert( dst.content().front().content_ids() == cids );
  assert( dst.content().front().event_ids().size() == 
          eids.size() + eids2.size() );

  msg("Bad merge again");
  assert( dst.merge(dst2) != 0 );

  msg("Lock");
  dst.lock();
  assert( dst.is_locked() );

  msg("Clone");
  Dataset* pdst_clone = dst.clone();
  assert( pdst_clone != 0 );
  cout << *pdst_clone << endl;
  assert( pdst_clone->is_valid() );
  assert( pdst_clone->is<VirtualEventDataset>() );
  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->content().front().event_ids() ==
          dst.content().front().event_ids() );
  assert( pdst_clone->content().front().content_ids() ==
          dst.content().front().content_ids() );

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

  msg("Read XML");
  GenericDataset gdst(*pele);
  assert( gdst.is_valid() );
  VirtualEventDataset dst3(gdst);
  cout << dst3 << endl;
  assert( dst3.is_valid() );
  assert( dst3.content() == dst.content() );
  assert( dst3.is_virtual() );

  msg("Create location");
  Location loc;
  Text txt1("myfile1.dat");
  txt1.append("data file");
  txt1.write();
  loc.files().push_back(Url("file:" + txt1.name()));
  cout << loc << endl;
  assert( ! loc.is_empty() );

  msg("Create non-virtual test dataset");
  GenericDataset nvdst(con, loc, "NonvirtualDataset");
  cout << nvdst << endl;
  assert( nvdst.is_valid() );
  assert( ! nvdst.is_virtual() );
  assert( nvdst.content() == con );
  cout << "Lock status: " << nvdst.lock() << endl;;
  assert( nvdst.is_locked() );

  msg("Use non-virtual dataset to construct virtual dataset");
  VirtualEventDataset vdst(nvdst);
  cout << vdst << endl;
  assert( vdst.is_valid() );
  assert( vdst.is_virtual() );
  assert( vdst.content() == con );
  assert( vdst.parent() == 0 );
  assert( ! vdst.is_locked() );
  vdst.lock();
  assert( vdst.is_locked() );
  
  msg("All tests passed.");
  return 0;
}

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