// CompoundJob_t.cxx

#include "dial_sched/CompoundJob.h"
#include <string>
#include <iostream>
#include <cassert>
#include "dataset_util/getcwd.h"
#include "dataset_util/mkdir.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_base/DatasetRepository.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dial_task/Task.h"
#include "dial_job/Job_t.h"

using std::string;
using std::ostream;
using std::cout;
using std::endl;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::Content;
using dset::Dataset;
using dial::Task;
using dial::Application;
using dial::JobPreferences;
using dial::JobId;
using dial::CompoundJob;

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

bool check_int(int stat, int check =0) {
  if ( stat == check ) return true;
  cout << "Found " << stat << "; expected " << check << endl;
  return false;
}

int CompoundJob_t() {

  system("rm -f resolver.dat dr.dat jobs");
  mkdir("jobs");

  //system("touch debug_CompoundJob");

  msg("Create dataset repository");
  assert( dset::DatasetRepository::create_default_instance() == 0 );

  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 application");
  SimpleUniqueIdGenerator::set_as_default();
  SimpleUniqueIdGenerator::create_collection(Application::id_context(), 11, 101);
  Application app = Application::test_instance();
  cout << app << endl;

  msg("Create task");
  SimpleUniqueIdGenerator::create_collection(Task::id_context(), 11, 101);
  Task tsk = Task::test_instance();
  cout << tsk << endl;

  msg("Create dataset 1");
  SimpleUniqueIdGenerator::create_collection("Dataset", 12, 1001);
  ContentIdList cids;
  EventIdList eids1;
  eids1.insert(EventId(101, 1001));
  eids1.insert(EventId(101, 1002));
  TestDataset dst1(Content("TestDataset", "test", cids, eids1));
  dst1.lock();
  cout << dst1 << endl;

  msg("Create dataset 2");
  EventIdList eids2;
  eids2.insert(EventId(101, 1003));
  eids2.insert(EventId(101, 1004));
  eids2.insert(EventId(101, 1005));
  TestDataset dst2(Content("TestDataset", "test", cids, eids2));
  dst2.lock();
  cout << dst2 << endl;

  msg("Create dataset 3");
  EventIdList eids3;
  eids3.insert(EventId(101, 1006));
  eids3.insert(EventId(101, 1007));
  TestDataset dst3(Content("TestDataset", "test", cids, eids3));
  dst3.lock();
  cout << dst3 << endl;

  msg("Create dataset 4");
  EventIdList eids4;
  eids4.insert(EventId(101, 1008));
  eids4.insert(EventId(101, 1009));
  eids4.insert(EventId(101, 1010));
  TestDataset dst4(Content("TestDataset", "test", cids, eids4));
  dst4.lock();
  cout << dst4 << endl;

  msg("Create overall dataset");
  EventIdList eids;
  eids.merge(eids1);
  eids.merge(eids2);
  eids.merge(eids3);
  eids.merge(eids4);
  TestDataset dst(Content("TestDataset", "test", cids, eids));
  dst.lock();
  cout << dst << endl;

  msg("Create preferences");
  JobPreferences prf;
  prf.lock();

  msg("Create compound job");
  string rundir = getcwd() + "/rundir";
  CompoundJob cjob(JobId(501,11), app, tsk, dst, prf, rundir,
                   100, 10, 0, 0);
  cout << cjob << endl;
  assert( cjob.is_valid() );
  assert( cjob.is_initialized() );

  msg("Add task subjob");
  TestJob jobt(JobId(501,10), app, tsk, dst1, prf, "jobs/jobt");
  cout << jobt << endl;
  assert( check_int(cjob.add_task_job(jobt)) );
  cout << cjob << endl;

  msg("Add 1st subjob");
  TestJob job1(JobId(501,1), app, tsk, dst1, prf, "jobs/job1");
  cout << job1 << endl;
  assert( check_int(cjob.add_job(job1)) );
  cout << cjob << endl;

  msg("Add 2nd subjob");
  TestJob job2(JobId(501,2), app, tsk, dst2, prf, "jobs/job2");
  cout << job2 << endl;
  assert( check_int(cjob.add_job(job2)) );
  cout << cjob << endl;

  msg("Add 3rd subjob");
  TestJob job3(JobId(501,3), app, tsk, dst3, prf, "jobs/job3");
  cout << job3 << endl;
  assert( check_int(cjob.add_job(job3)) );
  cout << cjob << endl;

  msg("Add 4rd subjob");
  TestJob job4(JobId(501,4), app, tsk, dst4, prf, "jobs/job4");
  cout << job4 << endl;
  assert( check_int(cjob.add_job(job4)) );
  cout << cjob << endl;
  cout << cjob.subjobs() << endl;

  msg("Check status");
  assert( cjob.is_initialized() );
  assert( check_int(cjob.subjobs().size(), 5) );
  assert( check_int(cjob.running_subjobs().size(), 0) );
  assert( check_int(cjob.done_subjobs().size(), 0) );
  assert( check_int(cjob.result_subjobs().size(), 0) );

  msg("Check full type");
  assert( cjob.full_type() == "CompoundJob" );

  msg("Check ID");
  assert( cjob.id().is_valid() );

  msg("Check run host");
  assert( cjob.run_host().size() );

  msg("Check job directory");
  assert( cjob.job_directory().size() );

  msg("Start job");
  assert( check_int(cjob.start()) );
  cout << cjob << endl;
  assert( check_int(cjob.running_subjobs().size(), 1) );
  assert( jobt.is_running() );
  assert( job1.is_initialized() );
  assert( job2.is_initialized() );
  assert( job3.is_initialized() );
  assert( job4.is_initialized() );

  msg("Try to add another subjob");
  TestJob job5(JobId(501,5), app, tsk, dst1, prf, "jobs/job5");
  cout << job5 << endl;
  assert( cjob.add_job(job5) != 0 );

  msg("End task job");
  jobt.end();
  cout << jobt << endl;
  assert( jobt.is_done() );
  assert( jobt.has_result() );

  msg("Update job");
  assert( check_int(cjob.update()) );
  cout << cjob << endl;
  cout << cjob.running_subjobs() << endl;
  assert( check_int(cjob.subjobs().size(), 5) );
  assert( check_int(cjob.done_subjobs().size(), 1) );
  assert( check_int(cjob.running_subjobs().size(), 4) );
  assert( job1.is_running() );
  assert( job2.is_running() );
  assert( job3.is_running() );
  assert( job4.is_running() );

  msg("End job 2");
  job2.end();
  cout << job2 << endl;
  assert( job2.is_done() );
  assert( job2.has_result() );
  assert( check_int(cjob.running_subjobs().size(), 4) );

  msg("Clone job 2 result");
  assert( job2.result() != 0 );
  const Dataset& xdst2 = *job2.result();
  cout << xdst2 << endl;
  Dataset* pxdst2c = xdst2.clone();
  assert( pxdst2c != 0 );
  cout << *pxdst2c << endl;

  msg("Update job");
  assert( check_int(cjob.update()) );
  cout << cjob << endl;
  assert( check_int(cjob.running_subjobs().size(), 3) );
  assert( check_int(cjob.done_subjobs().size(), 2) );
  assert( check_int(cjob.result_subjobs().size(), 1) );

  msg("Check result");
  assert( cjob.has_result() );
  cout << cjob.result() << endl;

  msg("End job 3");
  job3.end();
  assert( job3.is_done() );
  assert( check_int(cjob.running_subjobs().size(), 3) );

  msg("Update job");
  assert( check_int(cjob.update()) );
  cout << cjob << endl;
  assert( check_int(cjob.running_subjobs().size(), 2) );
  assert( check_int(cjob.done_subjobs().size(), 3) );
  assert( check_int(cjob.failed_subjobs().size(), 0) );
  assert( check_int(cjob.killed_subjobs().size(), 0) );
  assert( cjob.is_running() );

  msg("Fail job 1");
  job1.fail();
  assert( job1.is_failed() );

  msg("Update job");
  cjob.update();
  cout << cjob << endl;
  assert( check_int(cjob.running_subjobs().size(), 0) );
  assert( check_int(cjob.done_subjobs().size(), 3) );
  assert( check_int(cjob.failed_subjobs().size(), 1) );
  assert( check_int(cjob.killed_subjobs().size(), 1) );
  assert( cjob.is_failed() );

  msg("Check result");
  assert( cjob.has_result() );
  cout << cjob.result() << endl;

  msg("Fetch result");
  assert( cjob.has_result() );
  assert( cjob.result() != 0 );
  const Dataset& res = *cjob.result();
  cout << res << endl;
  assert( res.is_valid() );

  /*
     No point to the following until compound jobs can continue to run
     after a sub-job is failed or killed. 
  msg("Kill job 4");
  job4.kill();
  assert( job4.is_killed() );
  assert( check_int(cjob.killed_subjobs().size(), 1) );

  msg("Update job");
  assert( check_int(cjob.update()) );
  cout << cjob << endl;
  assert( check_int(cjob.running_subjobs().size(), 0) );
  assert( check_int(cjob.done_subjobs().size(), 2) );
  assert( check_int(cjob.failed_subjobs().size(), 1) );
  assert( check_int(cjob.killed_subjobs().size(), 1) );

  msg("Check result");
  assert( cjob.has_result() );
  cout << cjob.result() << endl;
  */

  return 0;

}

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