// DatasetRepository_t.cxx

#include "dataset_base/DatasetRepository.h"
#include <string>
#include <iostream>
#include <cassert>
#include "dataset_util/ThreadCredential.h"
#include "dataset_sql/SqlResultTable.h"
#include "dataset_sql/SqlResult.h"
#include "dataset_catalog/SqlGenericRepository.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_base/DatasetCreator_t.h"

using std::string;
using std::cout;
using std::endl;
using dset::Content;
using dset::SqlResult;
using dset::SqlResultTable;
using dset::SqlGenericRepository;
using dset::Dataset;
using dset::DatasetRepository;

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

} // end unnamed namespace
   
int DatasetRepository_t() {

  msg("Begin testing DatasetRepository");

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

  msg("Set thread owner");
  ThreadCredential().set_default_owner("someone");
  cout << ThreadCredential() << endl;

  msg("Constructor from a generic repository"); 
  string names[9] = { "identifier", "idhi", "idlo", "sxml", "owner",
                     "ctime", "comment", "created", "lastModified" };
  SqlResult::NameList cols(names, names+9);
  SqlResult res(cols);
  
  msg("Insert row specifying type");
  SqlResult::Row row0;
  row0["idhi"] = "0";
  row0["idlo"] = "0";
  row0["sxml"] = "DatasetRepository";
  res.insert_row(row0);
  assert( res.num_rows() == 1 );
   
  msg("Insert a row");
  SqlResult::Row row1;
  row1["idhi"] = "400";
  row1["idlo"] = "1";
  {
    TestDataset tdst;
    tdst.lock();
    const XmlElement* pxdst = tdst.xml();
    assert( pxdst != 0 );
    row1["sxml"] = pxdst->to_xml_text();
    cout << row1["sxml"] << endl;
    delete pxdst;
  }
  res.insert_row(row1);
  assert( res.num_rows() == 2 );
  
  msg("Insert another row");
  SqlResult::Row row2;
  row2["idhi"] = "400";
  row2["idlo"] = "2";
  {
    TestDataset tdst;
    tdst.lock();
    const XmlElement* pxdst = tdst.xml();
    assert( pxdst != 0 );
    row2["sxml"] = pxdst->to_xml_text();
    cout << row2["sxml"] << endl;
    delete pxdst;
  }
  res.insert_row(row2);
  assert( res.num_rows() == 3 );
  
  SqlResultTable sqltable(res);
  SqlGenericRepository sqlgr(sqltable);
  assert(sqlgr.is_valid());
 
  DatasetRepository drep(&sqlgr);
  cout << drep << endl;
	
  msg("Testing validity");
  assert( drep.is_valid() ); 
  assert( drep.size() == 2 );

  msg("Create test dataset");
  Content con;
  TestDataset tdb(con);
  Dataset& mdb = tdb;
  const Dataset& db1 = mdb;
  assert( db1.is_valid() );
  
  mdb.lock();
  cout << db1 << endl;
  assert( db1.is_locked() );
 
  msg("Write to repository");
  if ( !(drep.insert(&db1)).is_valid() ) {
    cout << "Insert failed with error: " << drep.error() << endl;
    cout << drep.error_message() << endl;
    assert(false);
  }
  assert( drep.size() == 3 );
 
  msg("Check valid dataset");
  if ( ! drep.has(db1.id()) ) {
    cout << "Check failed with error: " << drep.error() << endl;
    cout << drep.error_message() << endl;
    assert(false);
  }    
  
  msg("Read from repository");
  const Dataset *pds = drep.extract(db1.id());
  if ( pds == 0 || ! pds->is_valid() ) {
    cout << "Extract failed with error: " << drep.error() << endl;
    cout << drep.error_message() << endl;
    assert(false);
  } 
  cout << *pds << endl; 	
  
  msg("Remove from repository");
  if ( drep.remove(db1.id()) ) {
    cout << "Delete failed with error: " << drep.error() << endl;
    cout << drep.error_message() << endl;
    assert(false);
  }    
  assert( drep.size() == 2 );

  msg("Verify all entries");
  if ( !drep.verify() ) { 
    cout << "Verification failed" << endl;	  
    assert(false);
  }

  msg("Testing default instance");
  assert( DatasetRepository::create_default_instance() == 0 );
  DatasetRepository& dr = DatasetRepository::default_instance();
  assert( dr.is_valid() );
 
  msg("All tests passed successfully");
  return 0;
}

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