// JobRepository_t.cxx

#include "dial_job/JobRepository.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_catalog/SqlGenericRepository.h"
#include "dataset_catalog/ConnectionResolver.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dataset_sql/SqlResultTable.h"
#include "dataset_sql/SqlResult.h"
#include "dial_job/Job_t.h"
#include <string>
#include <iostream>
#include <cassert>

using std::string;
using std::cout;
using std::endl;
using dset::Content;
using dset::SqlResult;
using dset::SqlResultTable;
using dset::SqlGenericRepository;
using dset::ConnectionResolver;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dial::Application;
using dial::TaskId;
using dial::Task;
using dial::Job;
using dial::JobId;
using dial::JobPreferences;
using dial::JobRepository;

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

} // end unnamed namespace
   
int JobRepository_t() {
  msg("Begin testing JobRepository");

  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("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);

  msg("Create application");
  SimpleUniqueIdGenerator::set_as_default();
  SimpleUniqueIdGenerator::create_collection(Application::id_context(), 11, 101);
  const Application& app = Application::test_instance();
  cout << app << endl;
  
  msg("Create task");
  SimpleUniqueIdGenerator::create_collection(Task::id_context(), 200, 0);
  Text code("mycode.cxx");
  code.append("// Hello world");
  code.write();
  Task::NameList files;
  files.push_back("mycode.cxx");
  Task tsk(files);
  cout << tsk << endl;
  
  msg("Create dataset");
  EventIdList eids;
  eids.insert(EventIdRange(123,1,20));
  ContentIdList cids;
  TestDataset dst(Content("TestDataset", "test", cids, eids));
  dst.lock();
  
  msg("Create preferences");
  JobPreferences prf;
  prf.lock();
  
  msg("Create job.");
  TestJob job1(JobId(101,1), app, tsk, dst, prf, "./myjob");
  cout << job1 << endl;
  const XmlElement* pxjob = job1.xml();
  assert( pxjob != 0 );
  string sjob = pxjob->to_xml_text();
  
  msg("Insert row specifying type");
  SqlResult::Row row0;
  row0["idhi"] = "0";
  row0["idlo"] = "0";
  row0["sxml"] = "job";
  res.insert_row(row0);
  assert( res.num_rows() == 1 );

  msg("Insert a row");
  SqlResult::Row row1;
  row1["idhi"] = "101";
  row1["idlo"] = "1";
  row1["sxml"] = sjob; 
  res.insert_row(row1);
  assert( res.num_rows() == 2 );
  
  SqlResultTable sqltable(res);
  SqlGenericRepository sqlgr(sqltable);
  assert( sqlgr.is_valid() );

  JobRepository jrep(&sqlgr);
  cout << jrep << endl;

  msg("Testing validity");
  assert(jrep.is_valid()); 
  assert( jrep.size() == 1 );

  msg("Create new job.");
  TestJob job2(JobId(102,1), app, tsk, dst, prf, "myjob2");
  
  msg("Write to repository");
  if ( ! jrep.insert(&job2).is_valid()  ) {
    cout << "Insert failed with error: " << jrep.error() << endl;
    cout << jrep.error_message() << endl;
    assert(false);
  }
  assert( jrep.size() == 2 );
  assert( jrep.get_ids().size() == 2 );

  msg("Check valid job");
  if( !jrep.has(job2.id()) ) {
    cout << "Check failed with error: " << jrep.error() << endl;
    cout << jrep.error_message() << endl;
    assert(false);
  }
 
  msg("Read from repository");
  const Job *pjobn = jrep.extract(job2.id());
  if ( pjobn == 0 || !pjobn->is_valid() ) {
    cout << "Extract failed with error: " << jrep.error() << endl;
    cout << jrep.error_message() << endl;
  } 
  assert( pjobn != 0 );
  assert( pjobn->is_valid() );
  cout << *pjobn << endl;
  assert( pjobn == &job2 );
  assert( dynamic_cast<const TestJob*>(pjobn) != 0 );

  msg("Fetch copy from repository");
  Job* pjobc = jrep.copy(job2.id());
  assert( pjobc != 0 );
  assert( pjobc->is_valid() );
  cout << *pjobc << endl;
  assert( pjobc != &job2 );
  // Add the following if the repository is made smart enough to
  // promote to full type.
  //assert( dynamic_cast<const TestJob*>(pjobc) != 0 );

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

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

  msg("Define connection resolver");
  Text txt("resolver.dat");;
  txt.append("JobRepository");
  txt.append("SQLRESULT:jr.dat");
  txt.write();
  ConnectionResolver::set_configuration_file("resolver.dat");

  msg("Construct file description of JR");
  system("rm -f jr.dat");
  Text tjr("jr.dat");
  tjr.append("SQLRESULT");
  tjr.append("idhi,idlo,sxml");
  tjr.append("0,0,JobRepository");
  tjr.write();

  msg("Testing default instance");
  JobRepository& jr2 = JobRepository::default_instance();
  assert( jr2.is_valid() );

  msg("All tests passed successfully");
  return 0;
}

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