// ProcessJob_t.cxx

#include "dial_job/ProcessJob.h"
#include <string>
#include <iostream>
#include <cassert>
#include <vector>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "dataset_util/getcwd.h"
#include "dataset_util/FileStatus.h"
#include "dataset_util/FileName.h"
#include "dataset_util/mkdir.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_xml/XmlParser.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_base/DatasetRepository.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dial_task/Task.h"
#include "dial_app/Application.h"
#include "dial_job/ChildWatcher.h"

using std::string;
using std::ostream;
using std::cout;
using std::endl;
using std::vector;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::Dataset;
using dial::TaskId;
using dial::Task;
using dial::Application;
using dial::JobPreferences;
using dial::ChildWatcher;
using dial::JobId;
using dial::ProcessJob;

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

int ProcessJob_t() {

  system("rm -rf UniqueId");
  system("rm -f resolver.dat dr.dat");

  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 DTD");
  DtdRegistry::instance("dataset").write();
  DtdRegistry::instance("dial").write();
  FileName dset_dtdname(DtdRegistry::instance("dataset").filename());
  FileName dial_dtdname(DtdRegistry::instance("dial").filename());

  msg("Create application");
  system("touch build_task run");
  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");
  TestDataset dst;
  dst.lock();
  cout << dst << endl;

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

  msg("Create result in advance");
  string resfile = getcwd() + "/result.xml";
  // Write result locally.
  {
    TestDataset res;
    res.lock();
    cout << res << endl;
    const XmlElement* pxres = res.xml();
    assert( pxres != 0 );
    XmlParser parser;
    assert( parser.write(resfile, *pxres) == 0 );
  }

  msg("Create run directory");
  system("rm -rf job1");
  string dir = getcwd() + "/job1";
  assert( mkdir(dir) == 0 );

  msg("Create run command");
  Text runtxt;
  runtxt.append("touch std.log");
  runtxt.append("/bin/hostname");
  runtxt.append("/bin/pwd");
  runtxt.append("/bin/touch out.dat");
  runtxt.append("cp " + dset_dtdname.fullpath().name() + " .");
  runtxt.append("cp " + dial_dtdname.fullpath().name() + " .");
  runtxt.append("cp " + resfile + " .");
  string runfile = dir + "/dial_run_script";
  runtxt.write(runfile);
  string chcom = "chmod +x " + runfile;
  system(chcom.c_str());
  cout << runtxt << endl;

  msg("Create job.");
  ProcessJob job(JobId(201,1), app, tsk, dst, prf, dir, runfile);
  cout << job << endl;
  assert( job.is_initialized() );

  msg("Check full type");
  assert( job.full_type() == "ProcessJob" );

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

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

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

  msg("Start job");
  int jstat = job.start();
  cout << "Status is " << jstat << endl;
  cout << job << endl;
  assert( jstat == 0 );
  assert( job.is_running() || job.is_done() );

  msg("Wait for job to finish");
  for ( int count=0; count<10; ++count ) {
    cout << "..." << count << endl;
    ChildWatcher::print(cout) << endl;
    if ( ChildWatcher::live_count() == 0 ) break;
    job.update();
    sleep(1);
  }

  msg("Check job is done");
  cout << job << endl;
  assert( job.is_done() );

  msg("Create 2nd run directory");
  system("rm -rf job2");
  string dir2 = getcwd() + "/job2";
  assert( mkdir(dir2) == 0 );

  msg("Create run command");
  Text runtxt2;
  runtxt2.append("/bin/sleep 100");
  string runfile2 = dir2 + "/run2";
  runtxt2.write(runfile2);
  string chcom2 = "chmod +x " + runfile2;
  system(chcom2.c_str());
  cout << runtxt2 << endl;

  msg("Create job.");
  ProcessJob job2(JobId(201,2), app, tsk, dst, prf, dir2, runfile2);
  cout << job2 << endl;
  assert( job2.is_initialized() );

  msg("Start job");
  int jstat2 = job2.start();
  cout << "Status is " << jstat2 << endl;
  cout << job2 << endl;
  assert( jstat2 == 0 );
  assert( job2.is_running() || job2.is_done() );

  msg("Kill job");
  assert( job2.is_running() );
  assert( job2.kill() == 0 );
  cout << job2 << endl;
  assert( job2.is_killed() );

  msg("Create 3rd run directory");
  system("rm -rf job3");
  string dir3 = getcwd() + "/job3";
  assert( mkdir(dir3) == 0 );

  msg("Skip lsrun test.");
  return 0;

  msg("Create job with lsrun.");
  ProcessJob job3(JobId(201,3), app, tsk, dst, prf, dir3, runfile,
                  "/usr/lsf/bin/lsrun");
  cout << job3 << endl;
  assert( job3.is_initialized() );

  msg("Start job");
  int jstat3 = job3.start();
  cout << "Status is " << jstat2 << endl;
  cout << job3 << endl;
  assert( jstat3 == 0 );
  assert( job3.is_running() || job3.is_done() );

  msg("Wait for job to finish");
  for ( int count=0; count<10; ++count ) {
    cout << "..." << count << endl;
    ChildWatcher::print(cout) << endl;
    if ( ChildWatcher::live_count() == 0 ) break;
    sleep(1);
  }

  msg("Check job is done");
  cout << job3 << endl;
  assert( job3.is_done() );
  assert( job3.has_result() );
  return 0;

}

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