// HbookDataset_t.cxx

#include "dataset_CBNT/HbookDataset.h"
#include <iostream>
#include "dataset_util/FileStatus.h"
#include "dataset_util/XmlElement.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_base/DatasetCreator.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dataset_CBNT/HbookFile.h"
#include "dataset_CBNT/HbookFile_t.h"
#include "dataset_CBNT/HbookDataset.h"

using std::cout;
using std::endl;
using std::string;
using dset::Url;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::Dataset;
using dset::DatasetCreator;
using dset::GenericDataset;
using dset::HbookDataset;

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

int HbookDataset_t() {

  msg("Clean up");
  system("rm -f dataset.hbk");

  msg("Set ID generator");
  SimpleUniqueIdGenerator::create_collection("Dataset", 501, 0);
  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 promoter registration");
  assert( GenericDataset::has_promoter("HbookDataset") );

  msg("Find hbook file");
  string infile = find_file("hist.hbook");
  cout << infile << endl;
  assert( infile.size() != 0 );
  assert( FileStatus(infile).is_readable() );
  Url file("file:" + infile);
  
  msg("Create dataset");
  HbookDataset ds(file);
  cout << ds << endl;
  assert( ds.is_valid() );
  assert( ds.id().is_valid() );
  assert( ds.is_locked() );
  assert( ds.error() == 0 );
  assert( ds.filename() == infile );

  msg("Check type info");
  assert( ds.is<Dataset>() );
  assert( ds.is<HbookDataset>() );

  msg("Check hbook file");
  cout << ds.hbook_file() << endl;
  assert( ds.hbook_file().is_valid() );
  assert( ds.hbook_file().full_filename() == infile );

  msg("Clone");
  {
    Dataset* pdsc = ds.clone(getcwd());
    assert( pdsc != 0 );
    assert( ! pdsc->is_locked() );
    assert( pdsc->parent_id() == ds.id() );
    const Dataset& dsc = *pdsc;
    cout << dsc << endl;
    assert( dsc.is_valid() );
    assert( dsc.id().is_valid() );
    assert( ! (dsc.id() == ds.id()) );
    const HbookDataset& hdsc = dsc.cast<HbookDataset>();
    assert( hdsc.file().is_valid() );
    assert( hdsc.file() != file );
    assert( hdsc.error() == 0 );
    msg("Lock the clone");
    pdsc->lock();
    assert( dsc.is_locked() );
  }

  msg("Merge");
  HbookDataset* pdsc1 = &ds.clone(getcwd())->cast<HbookDataset>();
  HbookDataset* pdsc2 = &ds.clone(getcwd())->cast<HbookDataset>();
  cout << *pdsc1 << endl;
  cout << *pdsc2 << endl;
  pdsc2->lock();
  int mstat = pdsc1->merge(*pdsc2);
  cout << "Return status: " << mstat << endl;
  assert( mstat == 0 );
  delete pdsc1;
  delete pdsc2;

  msg("Create XML");
  const XmlElement* pele = ds.xml();
  assert( pele != 0 );
  cout << *pele << endl;

  msg("Reconstruct from XML");
  {
    const Dataset* pds2 = DatasetCreator::create(*pele);
    assert( pds2 != 0 );
    const Dataset& ds2 = *pds2;
    cout << ds2 << endl;
    assert( ds2.is_valid() );
    assert( ds2.id().is_valid() );
    assert( ds2.id() == ds.id() );
    assert( ds2.is_locked() );
    assert( ds2.is<HbookDataset>() );
    const HbookDataset& cds2 = ds2.cast<HbookDataset>();
    assert( cds2.file() == file );
    assert( cds2.error() == 0 );
    assert( cds2.hbook_file().is_valid() );
    assert( ! cds2.hbook_file().is_open() );
    delete pds2;
  }

  msg("DTD");
  assert( HbookDataset::dtd().size() != 0 );
  cout << HbookDataset::dtd() << endl;

  return 0;
}

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