// dial_submit_t.cxx

#include <string>
#include <iostream>
#include <unistd.h>
#include "dataset_util/getcwd.h"
#include "dataset_util/Environment.h"
#include "dataset_util/FileName.h"
#include "dataset_util/FileStatus.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_util/mkdir.h"
#include "dataset_xml/XmlParser.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_credential/CredentialSelectionCatalog.h"
#include "dataset_credential/GssCredentialManager.h"
#include "dataset_base/Dataset_t.h"
#include "dataset_base/EventMergeDataset.h"
#include "dataset_base/DatasetRepository.h"
#include "dial_task/Task.h"
#include "dial_app/Application.h"

using std::string;
using std::cout;
using std::endl;
using dset::Url;
using dset::CredentialSelectionCatalog;
using dset::GssCredentialManager;
using dset::Location;
using dset::Content;
using dset::Dataset;
using dset::EventMergeDataset;
using dset::DatasetRepository;
using dial::Task;
using dial::Application;

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

bool check(int value, int expect =0) {
  if ( value != expect ) {
    cout << "Found " << value << "; expected " << expect << endl;
  }
  return value == expect;
}

int dial_submit_t() {

  string plat = Environment::initial().value("CTG_PLATFORM");
  if ( plat == "rh73_gcc323" ) {
    msg("Skipping test of dial_submit on " + plat);
    return 0;
  }

  XmlParser parser;

  system("rm -rf dial dial_setup.sh UniqueId help run resolver.dat");
  system("rm -rf task.cxx app.xml task.xml dataset.xml");

  msg("Create dataset repository");
  assert( DatasetRepository::create_default_instance() == 0 );
  DatasetRepository& drep = DatasetRepository::default_instance();
  assert( drep.is_valid() );

  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("Check DTD registrations");
  DtdRegistry::display(cout) << endl;
  assert( DtdRegistry::is_registered("Application") );

  msg("Build DIAL environment");
  assert( check(system("export DIAL_UIDS=./UniqueId; dialenv")) );

  msg("Set UID generator");
  SimpleUniqueIdGenerator::set_as_default();

  msg("Check the dataset ID generator is global");
  assert( Dataset::id_generator().is_valid() );
  assert( Dataset::id_generator().is_global() );
  string uidcon = UniqueIdGenerator::connection();
  string uidcom = "DIAL_UIDS=" + uidcon;

  msg("Create setup script");
  {
    Text script("dial_setup.sh");
    assert( script.size() == 6 );
    script.append("");
    script.append("DIAL_CATALOG_CONF=" + getcwd() + "/resolver.dat");
    script.append("export DIAL_CATALOG_CONF");
    script.append("");
    script.append(uidcom);
    script.append("export DIAL_UIDS");
    script.write();
  }

  msg("Display help");
  mkdir("help");
  assert( check(system("cd help; export DIAL_UIDS=.././UniqueId; dial_submit -h")) );

  msg("Create application");
  {
    string pwd = getcwd();
    chdir("dial/apps/dialproc/test");
    Application app(Text::split("run build_task"));
    chdir(pwd.c_str());
    cout << app << endl;
    assert( app.is_valid() );

    msg("Create application XML");
    const XmlElement* pxapp = app.xml();
    assert( pxapp != 0 );
    cout << *pxapp << endl;
    assert( pxapp->name().size() );
    assert( check(parser.write("app.xml", *pxapp)) );
    delete pxapp;
  }

  msg("Create task");
  {
    Text txt("task.cxx");
    txt.append("#include \"dataset_id/EventId.h\"");
    txt.append("#include \"dataset_base/VirtualEventDataset.h\"");
    txt.append("");
    txt.append("using dset::ContentBlock;");
    txt.append("using dset::Content;");
    txt.append("using dset::Dataset;");
    txt.append("using dset::VirtualEventDataset;");
    txt.append("");
    txt.append("extern \"C\" int task(const EventId&, Dataset&);");
    txt.append("int task(const EventId& eid, Dataset& res) {");
    txt.append(
      "  VirtualEventDataset& veds = res.cast<VirtualEventDataset>();"
    );
    txt.append("  const ContentBlock& oldblk = veds.content().front();");
    txt.append("  EventIdList eids;");
    txt.append("  eids.insert(eid);");
    txt.append("  Content newcon(oldblk.dataset_type(), oldblk.name(),");
    txt.append("                 oldblk.content_ids(), eids);");
    txt.append("  VirtualEventDataset newdst(newcon);");
    txt.append("  veds.merge(newdst);");
    txt.append("  return 321;");
    txt.append("}");
    txt.write();
    Task::NameList files(1,txt.name());
    Task tsk(files);
    cout << tsk << endl;
    assert( tsk.is_valid() );
    assert( tsk.id().is_global() );
    string tskname = tsk.id().to_string();

    msg("Create task XML");
    const XmlElement* pxtsk = tsk.xml();
    assert( pxtsk != 0 );
    cout << *pxtsk << endl;
    assert( pxtsk->name().size() );
    assert( check(parser.write("task.xml", *pxtsk)) );
    delete pxtsk;
  }

  msg("Create task");
  {
    msg("Create dataset 1");
    EventIdList eids1;
    eids1.insert(EventIdRange(501,1,10));
    assert( eids1.size() == 10 );
    ContentId cid1("Test1", "more_junk");
    assert( cid1.is_valid() );
    ContentIdList cids;
    cids.insert(cid1);
    assert( cids.size() == 1 );
    Location loc1;
    system("touch test1.dat");
    string file1 = getcwd() + "/test1.dat";
    loc1.files().push_back(Url("file:" + file1));
    TestDataset dst1(Content("TestDataset", "test", cids, eids1), loc1);
    dst1.lock();
    assert( dst1.is_valid() );
    drep.insert(&dst1);

    msg("Create dataset 2");
    EventIdList eids2;
    eids2.insert(EventIdRange(501,11,25));
    assert( eids2.size() == 15 );
    Location loc2;
    system("touch test2.dat");
    string file2 = getcwd() + "/test2.dat";
    loc2.files().push_back(Url("file:" + file2));
    TestDataset dst2(Content("TestDataset", "test", cids, eids2), loc2);
    dst2.lock();
    assert( dst2.is_valid() );
    drep.insert(&dst2);

    msg("Create merged dataset");
    Content conm("TestDataset", "test", cids, EventIdList());
    EventMergeDataset mdst(false, conm);
    assert( check(mdst.merge(dst1)) );
    assert( check(mdst.merge(dst2)) );
    mdst.lock();
    cout << mdst << endl;
    assert( mdst.is_valid() );
    assert( mdst.event_ids().size() == 25 );

    msg("Create dataset XML.");
    const XmlElement* pxdst = mdst.xml();
    assert( pxdst != 0 );
    cout << *pxdst << endl;
    assert( pxdst->name().size() );
    assert( check(parser.write("dataset.xml", *pxdst)) );
    delete pxdst;
  }

  msg("Configure run directory");
  system("pwd");
  system("ls -ls");
  mkdir("run");
  system("cp app.xml run");
  system("cp task.xml run");
  system("cp dataset.xml run");
  system("ls -ls run");
  assert( FileStatus("run/app.xml").is_readable() );

  Text ctxt("run/dial_submit.cnf");
  assert( ctxt.size() == 0 );
  ctxt.append("single_update");
  ctxt.write();

  msg("Run job");
  string com = ". dial_setup.sh";
  com += "; export DIAL_UIDS=SimpleUniqueIdGenerator:"
         + getcwd() + "/UniqueId:3:false";
  com += "; cd run";
  com += "; dial_submit";
  cout << com << endl;
  assert( check(system(com.c_str())) );

  msg("Check directory after submission");
  system("ls -ls run");
  assert( FileStatus("run/dataset.dtd").is_readable() );
  assert( FileStatus("run/dial.dtd").is_readable() );

  msg("Test complete");
  return 0;
}

#ifdef CTEST_MAIN
int main() {

  // Diap
  return dial_submit_t();
}
#endif