// TaskRepository_t.cxx

#include "dial_task/TaskRepository.h"
#include "dataset_catalog/SqlGenericRepository.h"
#include "dataset_catalog/ConnectionResolver.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_sql/SqlResultTable.h"
#include "dataset_sql/SqlResult.h"
#include "dataset_util/Text.h"
#include "dataset_util/XmlElement.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include <string>
#include <iostream>
#include <cassert>

using std::string;
using std::cout;
using std::endl;
using dset::SqlResult;
using dset::SqlResultTable;
using dset::SqlGenericRepository;
using dset::ConnectionResolver;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dial::Task;
using dial::TaskId;
using dial::TaskRepository;

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

} // end unnamed namespace
   
int TaskRepository_t() {
  msg("Begin testing TaskRepository");

  msg("Constructor from a generic repository");
  //Constructing a Result set to construct a SqlResultTable.
  string names[9] = { "identifier", "idhi", "idlo", "sxml", "owner",
                     "ctime", "comment", "created", "lastModified" };
  SqlResult::NameList cols(names, names+9);                        
  SqlResult res(cols);
  
  int ustat = SimpleUniqueIdGenerator::create_collection("Task", 200, 0);
  assert( ustat == 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("Create task1 from files");
  Text abc("abc.dat");
  abc.append("Testing TaskRepository-1");
  abc.write();
  Task::NameList files1;
  files1.push_back("abc.dat");
  Task tsk1(files1);
  assert(tsk1.is_valid());
  const XmlElement *pele = tsk1.xml();
  string xml1 = pele->to_xml_text(); 
  
  msg("Create task2 from files");
  Text def("def.dat");
  def.append("Testing TaskRepository-2");
  def.write();
  Task::NameList files2;
  files2.push_back("def.dat");
  Task tsk2(files2);
  assert(tsk2.is_valid());
  pele = tsk2.xml();
  string xml2 = pele->to_xml_text();
     
  msg("Insert row specifying type");
  SqlResult::Row row0;
  row0["idhi"] = "0";
  row0["idlo"] = "0";
  row0["sxml"] = "task";
  res.insert_row(row0);
  assert( res.num_rows() == 1 );

  msg("Insert a row");
  SqlResult::Row row1;
  row1["idhi"] = "400";
  row1["idlo"] = "1";
  row1["sxml"] = xml1; 
  res.insert_row(row1);
  assert( res.num_rows() == 2 );

  msg("Insert another row");
  SqlResult::Row row2;
  row2["idhi"] = "400";
  row2["idlo"] = "2";
  row2["sxml"] = xml2;
  assert( res.insert_row(row2) == 0 );
  assert( res.num_rows() == 3 );
                                                                        
  SqlResultTable sqltable(res);
  SqlGenericRepository sqlgr(sqltable);
  assert( sqlgr.is_valid() );

  TaskRepository trep(&sqlgr);

  msg("Testing validity");
  assert(trep.is_valid()); 
  assert( trep.size() == 2 );
 
  Text code("mycode.cxx");
  code.append("int myfun() {");
  code.append("  return 123;");
  code.append("}");
  code.write();
                                                                         
  Text conf("config.dat");
  conf.append("min = -20.0");
  conf.append("max = 40.0");
  conf.append("nbin = 150");
  conf.write();
                                                                        
  msg("Create task from files");
  Task::NameList files;
  files.push_back("mycode.cxx");
  files.push_back("config.dat");
  Task tsk(files);
  assert( tsk.is_valid() );

  msg("Write to repository");
  if ( ! trep.insert(&tsk).is_valid()  ) {
    cout << "Insert failed with error: " << trep.error() << endl;
    cout << trep.error_message() << endl;
    assert(false);
  }
  assert( trep.size() == 3 );

  msg("Check valid task");
  if ( !trep.has(tsk.id()) ) {
    cout << "Check failed with error: " << trep.error() << endl;
    cout << trep.error_message() << endl;
    assert(false);
  }
 
  msg("Read from repository");
  const Task *ptsk = trep.extract(tsk.id());
  if ( ptsk == 0 || !ptsk->is_valid() ) {
    cout << "Extract failed with error: " << trep.error() << endl;
    cout << trep.error_message() << endl;
    assert(false);
  } 
  cout << *ptsk << endl;

  msg("Remove from repository");
  if ( trep.remove(tsk.id()) ) {
    cout << "Delete failed with error: " << trep.error() << endl;
    cout << trep.error_message() << endl;
    assert(false);
  }
  assert( trep.size() == 2 );

  msg("Verify all entries");
  if( !trep.verify() ) {
    cout << "Verification failed" << endl;
    assert(false);
  }
  
  msg("Define connection resolver");
  Text txt("resolver.dat");;
  txt.append("TaskRepository");
  txt.append("SQLRESULT:tr.dat");
  txt.write();
  ConnectionResolver::set_configuration_file("resolver.dat");

  msg("Construct file description of TR");
  system("rm -f tr.dat");
  Text ttr("tr.dat");
  ttr.append("SQLRESULT");
  ttr.append("idhi,idlo,sxml");
  ttr.append("0,0,TaskRepository");
  ttr.write();

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

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