// dialenv_t.cxx

// David Adams
// February 2003
// Updated August 2003
//
// Creates the environment required to run dialproc from DIAL.
//
// The follwing enviroment is assumed:
//   DIAL_APPS = PWD/dial/apps
//   DIAL_TASKS = PWD/dial/tasks
//   DIAL_JOBS = PWD/dial/jobs
// where PWD is the current working directory.
//
// The application dialproc/test is installed.

#include <string>
#include <iostream>
#include <cassert>
#include <vector>
#include <unistd.h>
#include "dataset_base/DatasetCreator_t.h"
#include "dataset_util/FileStatus.h"
#include "dataset_util/FileName.h"
#include "dataset_util/getcwd.h"
#include "dataset_util/FileFinder.h"
#include "dataset_util/mkdir.h"
#include "dataset_util/Path.h"
#include "dataset_util/Environment.h"
#include "dataset_util/CommandLine.h"
#include "dataset_util/DtdRegistry.h"
#include "dataset_id/SimpleUniqueIdGenerator.h"
#include "dataset_base/DatasetCreator.h"
#include "dataset_base/Dataset_t.h"
#include "dial_task/Task.h"
#include "dial_job/Job.h"
// Needed for testing
#include "dataset_base/Dataset_t.h"

using std::string;
using std::ostream;
using std::cout;
using std::cerr;
using std::endl;
using std::vector;
using dset::DatasetCreator;

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

using dial::Task;
using dial::Application;

string DSEP = FileName::string_delimiter();

int dialenv() {

  msg("Initialize dataset creator");
  DatasetCreator::display(cout);
  cout << endl;

  msg("Create DTD");
  Text dial_dtd = DtdRegistry::instance("dial").text();
  string dial_dtdname = DtdRegistry::instance("dial").filename();
  Text dset_dtd = DtdRegistry::instance("dataset").text();
  string dset_dtdname = DtdRegistry::instance("dataset").filename();

  msg("Fetch current directory");
  string cwdir = getcwd();

  msg("Create ID directories");
  system("rm -rf UniqueId");
  SimpleUniqueIdGenerator::create_collection("Application", 601, 0);
  SimpleUniqueIdGenerator::create_collection("Task", 101, 0);
  SimpleUniqueIdGenerator::create_collection("Dataset", 201, 0);
  SimpleUniqueIdGenerator::create_collection("Dataset", 202, 0);
  SimpleUniqueIdGenerator::create_collection("Dataset", 203, 0);
  SimpleUniqueIdGenerator::create_collection("Dataset", 204, 0);
  SimpleUniqueIdGenerator::create_collection("Dataset", 205, 0);
  SimpleUniqueIdGenerator::create_collection("Job", 301, 0);
  SimpleUniqueIdGenerator::create_collection("JobPreferences", 401, 0);
  string uiddir = cwdir + "/UniqueId";
  SimpleUniqueIdGenerator::set_as_default(uiddir);
  string conn = "SimpleUniqueIdGenerator:" + uiddir + ":5:true";

  msg("Create DIAL directories");
  system("rm -rf dial");
  assert( mkdir("dial") == 0 );

  msg("...application");
  string appname = "dialproc";
  string appdir = cwdir + DSEP + "dial/apps";
  string dial_apps = appdir;
  assert( mkdir(appdir) == 0 );
  appdir += DSEP + appname;
  assert( mkdir(appdir) == 0 );
  appdir += DSEP + "test";
  assert( mkdir(appdir) == 0 );
  // Write DTD.
  assert( dset_dtd.write(appdir+DSEP+dset_dtdname) == 0 );
  assert( dial_dtd.write(appdir+DSEP+dial_dtdname) == 0 );

  msg("...task");
  string tskdir = cwdir + DSEP + "dial/tasks";
  string dial_tasks = tskdir;
  assert( mkdir(tskdir) == 0 );

  // Write task build command file.

  // Generate include path.
  // Search for headers at DIAL_HEADER_DIR, DIAL_HEADER_DIR/pkgname
  // and on CTG development and installation paths.
  vector<string> pkgs;
  pkgs.push_back("dataset/dataset_util");
  pkgs.push_back("dataset/dataset_id");
  pkgs.push_back("dataset/dataset_file");
  pkgs.push_back("dataset/dataset_base");
  pkgs.push_back("dial/dial_task");
  string flag = " -I";
  string sep = "/";
  string incs;
  Environment sysenv;
  sysenv.sysfill();
  string hbase = sysenv.value("DIAL_HEADER_DIR");
  string devpath = sysenv.value("CTG_DEVPATH");
  string inspath = sysenv.value("CTG_DEVPATH");
  // Use DIAL_HEADER_DIR if defined.
  if ( hbase.size() ) {
    string fullpkg = pkgs.front();
    string::size_type ipos = fullpkg.rfind(sep);
    string pkg = fullpkg.substr(ipos+1);
    if ( FileStatus(hbase+sep+pkg+sep+pkg).is_directory() ) {
      for ( vector<string>::const_iterator ipkg=pkgs.begin();
            ipkg!=pkgs.end(); ++ipkg ) {
        incs += flag + hbase + sep + pkg;
      }
    } else {
      incs += flag + hbase;
    }
  // Otherwise use CTG development locations.
  } else if ( devpath.size() ) {
    Text::WordList devdirs = Text::split(devpath, ":");
    for ( vector<string>::const_iterator ipkg=pkgs.begin();
          ipkg!=pkgs.end(); ++ipkg ) {
      string fullpkg = *ipkg;
      string incdir;
      for ( Text::WordList::const_iterator idir=devdirs.begin();
            idir!=devdirs.end(); ++idir ) {
        string devdir = *idir;
        incdir = devdir + sep + fullpkg;
        if ( FileStatus(incdir).is_directory() ) {
          incs += flag + incdir;
          break;
        }
      }
    }
  // Otherwise use the CTG installation location.
  } else if ( inspath.size() ) {
    Text::WordList insdirs = Text::split(inspath, ":");
    for ( Text::WordList::const_iterator idir=insdirs.begin();
          idir!=insdirs.end(); ++idir ) {
      string insdir = *idir;
      incs += flag + insdir + sep + "include";
    }
  } else {
    cerr << "dialenv: None of DIAL_HEADER_DIR, CTG_DEVPATH, CTGINSPATH"
         << " are defined." << endl;
    assert(false);
  }

  // Build command to compile.
  Path exepath;
  exepath.getenv("PATH");
  assert( exepath.size() != 0 );
  Text buildcom;
  Path gpath = exepath.find("g++");
  assert( gpath.size() > 0 );
  string gfile = gpath.front() + DSEP + "g++";
  assert( FileStatus(gfile).is_executable() );
  buildcom.append("echo Environment:");
  buildcom.append("set");
  buildcom.append("echo");
  buildcom.append("echo Exports:");
  buildcom.append("export -p");
  buildcom.append("echo");
  buildcom.append("echo Compiling...");
  buildcom.append(gfile + incs + " -g -shared -o task.so task.cxx");
  buildcom.append("if [ -r task.so ]; then");
  buildcom.append("  touch task_installed");
  buildcom.append("else");
  buildcom.append("  touch task_install_failed");
  buildcom.append("fi");
  string comfile = appdir + DSEP + "build_task";
  buildcom.write(comfile);
  string chcom = "chmod +x " + comfile;
  system(chcom.c_str());

  msg("...job");
  string jobdir = cwdir + DSEP + "dial/jobs";
  string dial_jobs = jobdir;
  assert( mkdir(jobdir) == 0 );

  msg("Build application description");
  // Write run script.
  string exe;
  {
    // Search for executable.
    string exepath = Environment::current().value("PATH");
    Text::WordList exedirs = Text::split(exepath, ":");
    for ( Text::WordList::const_iterator idir=exedirs.begin();
          idir!=exedirs.end(); ++idir ) {
      exe = *idir + "/dialproc";
      if ( FileStatus(exe).is_executable() ) break;
      exe = "";
    }
    if ( exe == "" ) {
      cerr << "dialenv: Unable to find dialproc on PATH";
      assert(false);
    }
  }
  // Find external setup file.
  string extset = exe.substr(0, exe.size()-8) + "extsetup.sh";
  Text runtxt;
  runtxt.append("#!/bin/sh");
  runtxt.append("");
  runtxt.append("DIAL_UIDS=" + conn);
  runtxt.append("export DIAL_UIDS");
  runtxt.append("");
  runtxt.append("DIAL_CATALOG_CONF=" + getcwd() + "/resolver.dat");
  runtxt.append("export DIAL_CATALOG_CONF");
  runtxt.append("");
  runtxt.append("echo env");
  runtxt.append("set");
  runtxt.append("");
  runtxt.append("echo Exports");
  runtxt.append("export -p");
  runtxt.append("");
  runtxt.append("echo Local listing");
  runtxt.append("ls -ls");
  runtxt.append("");
  runtxt.append("echo Task listing");
  runtxt.append("ls -ls `cat taskdir`");
  runtxt.append("");
  runtxt.append("echo " + exe);
  runtxt.append(". " + extset);
  runtxt.append(exe);
  string runfile = appdir + DSEP + "run";
  runtxt.write(runfile);
  string chrcom = "chmod +x " + runfile;
  system(chrcom.c_str());

  msg("Build setup file");
  Text setup;
  setup.append("DIAL_APPS=" + dial_apps);
  setup.append("DIAL_TASKS=" + dial_tasks);
  setup.append("DIAL_JOBS=" + dial_jobs);
  setup.append("export DIAL_APPS");
  setup.append("export DIAL_TASKS");
  setup.append("export DIAL_JOBS");
  setup.write("dial_setup.sh");

  return 0;
}

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