#include "tasks.h"

#include "tconvert.h"

#include "casmfileinfo.h"

#include "util.h"

#include "texception.h"

#include "tsystem.h"

#define DDR_OUTPUTSCRIPT_FILENAME "D@D@R"

//==============================================================================

string SubmitPageTask::getFilePath() { return m_filePath; }

//------------------------------------------------------------------------------

void SubmitPageTask::setFilePath(const string &filePath) {

  m_filePath = filePath;

}

//------------------------------------------------------------------------------

string SubmitPageTask::getName() { return m_name; }

//------------------------------------------------------------------------------

void SubmitPageTask::setName(const string &name) { m_name = name; }

//------------------------------------------------------------------------------

map<string, string=""> SubmitPageTask::getDependencies() { return m_depTasks; }</string,>

//------------------------------------------------------------------------------

void SubmitPageTask::setDependencies(const map<string, string=""> &tasks) {</string,>

  m_depTasks = tasks;

}

//------------------------------------------------------------------------------

void SubmitPageTask::checkNameUnc() {

  if (m_filePath == "") return;

  TFilePath fp(m_filePath);

  string uncString = "";

  try {

    uncString = convertToUncString(fp);

  } catch (TException &) {

    if (!TFileStatus(fp).doesExist()) {

      string msg = toString(fp.getWideString()) + "\n";

      msg += "File not found\n";

      msg += "Please verify that the path is correct";

      throw TException(msg);

    }

  }

}

//==============================================================================

CasmTask2::CasmTask2() { setDefaultValue(); }

//------------------------------------------------------------------------------

CasmTask2::CasmTask2(const string &s, const string &setupFilePath)

    : m_setupFile(setupFilePath) {

  setCommandLine(s);

}

//------------------------------------------------------------------------------

void CasmTask2::setDefaultValue() {

  m_taskChunksize        = 1;

  m_start                = 0;

  m_end                  = 9999;

  m_step                 = 1;

  m_filePath             = "";

  m_name                 = "";

  m_outname              = "";

  m_firstFrame           = 0;

  m_lastFrame            = 0;

  m_reduction            = 1;

  m_moveType             = M_BG_FRACMOVE;

  m_prec                 = 32;

  m_renderTile           = 1.;

  m_memChunk             = 4.;

  m_multimedia           = false;

  m_logfile              = false;

  m_cf                   = false;

  m_restype              = RES_TYPE_STANDARD;

  m_noOverwrite          = false;

  m_clap                 = false;

  m_mprocess             = false;

  m_numColumn            = -1;

  m_lineart              = -1;

  m_edgeAliasing         = -1;

  m_gamma                = -1.;

  m_bcScript             = "";

  m_acScript             = "";

  m_outputScript         = "";

  m_outputScriptArgument = "";

  m_setupFile            = "";

  xsize                  = 0;

  ysize                  = 0;

}

//------------------------------------------------------------------------------

void CasmTask2::setFileArg(const string &fp) {

  TFilePath filePath = TFilePath(fp);

  CasmFileInfo casmFileInfo(filePath);

  int start, end;

  bool interlaced;

  casmFileInfo.getFrameRange(start, end, interlaced);

  m_filePath = fp;

  m_start    = start;

  m_end      = end;

  m_step     = 1;

  setName(TFilePath(fp).getName());

}

//------------------------------------------------------------------------------

string CasmTask2::getCommandLine() const {

  string qualifiers, prgname, dirname, biname;

  if (m_reduction != 1) qualifiers += " -shrink " + toString(m_reduction) + " ";

  if (m_moveType != moveType::M_BG_FRACMOVE)

    qualifiers +=

        (m_moveType == moveType::M_FRACMOVE) ? " -fracmove " : " -intmove ";

  if (m_prec == 64)

    qualifiers += " -64bit";

  else

    qualifiers += " -32bit";

  qualifiers += " -tile " + toString(m_renderTile) + " ";

  qualifiers += " -mem " + toString(m_memChunk) + " ";

  if (m_multimedia) {

    if (m_numColumn < 0)

      qualifiers += " -mm ";

    else

      qualifiers += " -mmsingle " + toString(m_numColumn) + " ";

  }

  if (m_logfile) qualifiers += " -logfile +output/casm_batches.log ";

  if (m_lineart > -1) qualifiers += " -lineart " + toString(m_lineart) + " ";

  if (m_edgeAliasing > -1)

    qualifiers += " -edgealiasing " + toString(m_edgeAliasing) + " ";

  if (m_gamma > -1.0) qualifiers += " -gamma " + toString(m_gamma) + " ";

  switch (m_restype) {

    CASE RES_TYPE_STANDARD : qualifiers += " -sq ";

    CASE RES_TYPE_IMPROVED : qualifiers += " -iq ";

    CASE RES_TYPE_HIGH : qualifiers += " -hq ";

  }

  if (m_cf) qualifiers += " -cf ";

  if (m_noOverwrite) qualifiers += " -no_overwrite ";

  if (m_clap) qualifiers += " -clap ";

  if (m_bcScript != "") qualifiers += " -bc " + m_bcScript + " ";

  if (m_acScript != "" && m_outputScript == "")

    qualifiers += " -ac " + m_acScript + " ";

  if (m_outputScript != "") {

    bool outputToDdr = (m_outputScript == DDR_OUTPUTSCRIPT_FILENAME);

    if (!outputToDdr) qualifiers += " -ac " + m_outputScript + " ";

    if (m_outputScriptArgument != "") {

      string entry_point = m_outputScriptArgument;

      string parity      = "odd";

      int i;

      i = entry_point.size();

      if (i > 0 && entry_point[i - 1] == '+') {

        parity             = "even";

        entry_point[i - 1] = '\0';

      }

      // convert_timecode_to_frame (entry_point);//??????

      if (outputToDdr)

        qualifiers += " -ddr " + entry_point + " ";

      else {

        string app;

#ifdef WIN32

        app = " -ac_args \"$filename $count " + entry_point;

        app += " " + parity;

        app += " $total\" ";

        qualifiers += app;

#else

        app = " -ac_args '$filename $count " + entry_point;

        app += " " + parity;

        app += " $total' ";

        qualifiers += " app;

#endif

      }

    } else {

      if (outputToDdr)

        qualifiers += " -ddr " + toString(0) + " ";

      else

#ifdef WIN32

        qualifiers += " -ac_args \"$filename $count $total\" ";

#else

        qualifiers += " -ac_args '$filename $count $total' ";

#endif

    }

  }

  qualifiers += "  -step " + toString(m_step);

  if (m_start > m_firstFrame || m_end < m_lastFrame)

    qualifiers += " -range " + toString(m_start) + " " + toString(m_end) + " ";

  // qualifiers += " -chunk "+toString(m_taskChunksize)+" ";

  return qualifiers;

}

//------------------------------------------------------------------------------

static bool is_num(string word) {

  string::iterator it = word.begin();

  while (it != word.end()) {

    if ((*it < '0' || *it > '9') && *it != '.') return false;

    it++;

  }

  return true;

}

//------------------------------------------------------------------------------

static string cpy_word(string &word, string s) {

  /* salto gli spazi bianchi iniziali */

  string::iterator it  = s.begin();

  word                 = "";

  string::iterator it2 = word.begin();

  while (s[0] == ' ' || s[0] == '\t') it++;

  if (s[0] == '\'' || s[0] == '\"') {

    /* argomento fra virgolette */

    char quote = *it++;

    while (*it && *it != '\n') {

      if (*it == '\\') {

        it++;

        if (*it == '\0' || *it == '\n') break;

        switch (*it) {

          CASE '\\' : *it2++ = '\\';

        DEFAULT:

          *it2++ = *it;

        }

        it++;

      } else if (*it == quote) {

        it++;

        break;

      } else

        *it2++ = *it++;

    }

  } else {

    /* argomento senza virgolette */

    while (*it && *it != ' ' && *it != '\t' && *it != '\n') *it2++ = *it++;

  }

  //*word = '\0';

  /* salto gli spazi bianchi finali */

  while (*it == ' ' || *it == '\t') it++;

  return s.erase(s.begin(), it);

}

//------------------------------------------------------------------------------

void CasmTask2::setCommandLine(const string &cmdLine) {

  if (cmdLine.empty()) return;

  setDefaultValue();

  string s            = cmdLine;

  string::iterator it = s.begin();

  string word;

  while (it != s.end()) {

    s = cpy_word(word, s);

    if (word == "-64bit")

      m_prec = 64;

    else if (word == "-32bit")

      m_prec = 32;

    else if (word == "-sq")

      m_restype = RES_TYPE_STANDARD;

    else if (word == "-iq")

      m_restype = RES_TYPE_IMPROVED;

    else if (word == "-hq")

      m_restype = RES_TYPE_HIGH;

    else if (word == "-step") {

      s                        = cpy_word(word, s);

      if (is_num(word)) m_step = atoi(word.c_str());

    } else if (word == "-range") {

      s                         = cpy_word(word, s);

      if (is_num(word)) m_start = atoi(word.c_str());

      s                         = cpy_word(word, s);

      if (is_num(word)) m_end   = atoi(word.c_str());

    } else if (word == "-shrink") {

      s                             = cpy_word(word, s);

      if (is_num(word)) m_reduction = atoi(word.c_str());

    } else if (word == "-fracmove") {

      m_moveType = M_FRACMOVE;

    } else if (word == "-intmove") {

      m_moveType = M_INTMOVE;

    }

    /*     else

if (STR_EQ(word, "-64bit"))

task->prec = 64;

else

if (STR_EQ(word, "-32bit"))

task->prec = 32;*/

    else if (word == "-tile") {

      s                              = cpy_word(word, s);

      if (is_num(word)) m_renderTile = atof(word.c_str());

    } else if (word == "-mem") {

      s                                 = cpy_word(word, s);

      if (is_num(word)) m_taskChunksize = atoi(word.c_str());

    } else if (word == "-chunk") {

      s                            = cpy_word(word, s);

      if (is_num(word)) m_memChunk = atof(word.c_str());

    } else if (word == "-mm") {

      m_multimedia = true;

      m_numColumn  = -1;

    } else if (word == "-mmsingle") {

      m_multimedia                  = true;

      s                             = cpy_word(word, s);

      if (is_num(word)) m_numColumn = atoi(word.c_str());

    } else if (word == "-lineart") {

      s                           = cpy_word(word, s);

      if (is_num(word)) m_lineart = atoi(word.c_str());

    } else if (word == "-edgealiasing") {

      s                                = cpy_word(word, s);

      if (is_num(word)) m_edgeAliasing = atoi(word.c_str());

    } else if (word == "-gamma") {

      s                         = cpy_word(word, s);

      if (is_num(word)) m_gamma = atof(word.c_str());

    } else if (word == "-cf") {

      m_cf = true;

    } else if (word == "-no_overwrite") {

      m_noOverwrite = true;

    } else if (word == "-clap") {

      m_clap = true;

    } else if (word == "-bc") {

      s          = cpy_word(word, s);

      m_bcScript = word;

    } else if (word == "-ac") {

      s              = cpy_word(word, s);

      m_outputScript = word;

    } else if (word == "-ac_args") { /*

char output_script_argument[1024];

s = cpy_word(word, s);

if(parse_ac_args(output_script_argument, word))

task->output_script_argument = strsave(output_script_argument);*/

    } else if (word == "-logfile") {

      s         = cpy_word(word, s);

      m_logfile = true;

    }

    /*     else

if (!word.compare("-range"))

{

s = cpy_word(word, s);

if (is_num(word))

task->start = atoi(word);

else

{

delete_job((TASK *)task);

return NULL;

}

s = cpy_word(word, s);

if (is_num(word))

task->end = atoi(word);

else

{

delete_job((TASK *)task);

return NULL;

}

}*/

    /*     else

if (*word!='\n' && *word!='\0')

{

t = tim_get_type(word);

if (*t == '.') t++;

if (FILESTR_NE(t, "casm"))

{

delete_job((TASK *)task);

//           return NULL;

}

else

{

TCALLOC(task->casm_file, strlen(word)+1);

strcpy(task->casm_file, word);

compute_casm_range(task->casm_file, &(task->first_frame), &(task->last_frame),

&dummy);

if (task->start<task->first_frame)</task->

  task->start=task->first_frame;

if (task->end>task->last_frame)

  task->end=task->last_frame;

task->xsize = task->ysize = 0;

casm_camera_size(task->casm_file, &task->xsize, &task->ysize);

}

}*/

    it = s.begin();

  }

}

//------------------------------------------------------------------------------

void CasmTask2::checkNameUnc() {

  SubmitPageTask::checkNameUnc();

  if (m_setupFile == "") return;

  TFilePath fp(m_setupFile);

  string uncString = "";

  try {

    uncString = convertToUncString(fp);

  } catch (TException &) {

    if (!TFileStatus(fp).doesExist()) {

      string msg = toString(fp.getWideString()) + "\n";

      msg += "File not found\n";

      msg += "Please verify that the path is correct";

      throw TException(msg);

    }

  }

}

//==============================================================================

ScriptTask::ScriptTask() { setDefaultValue(); }

//------------------------------------------------------------------------------

ScriptTask::ScriptTask(const string &s, const string &setupFilePath)

    : m_setupFile(setupFilePath) {

  setCommandLine(s);

}

//------------------------------------------------------------------------------

void ScriptTask::setFileArg(const string &fp) {

  m_filePath = fp;

  m_name     = TFilePath(fp).getName();

}

//------------------------------------------------------------------------------

string ScriptTask::getCommandLine() const {

  string cmdLine;

  if (m_filePath == "") {

    assert(false);

    return "";

  }

#ifdef WIN32

  /*

if (is_fg)

cmdLine = m_filePath;

else

*/

  // viene sempre fatto girare in background

  cmdLine = "CALL " + m_filePath + " ";

#else

  cmdLine = m_filePath;

#endif

  cmdLine += "   ";

  if (m_arg1 != "") cmdLine += m_arg1 + "   ";

  if (m_arg2 != "") cmdLine += m_arg2 + "   ";

  if (m_arg3 != "") cmdLine += m_arg3 + "   ";

  if (m_arg4 != "") cmdLine += m_arg4 + "   ";

  if (m_arg5 != "") cmdLine += m_arg5 + "   ";

  return cmdLine;

}

//------------------------------------------------------------------------------

void ScriptTask::setCommandLine(const string &cmdLine) {

  setDefaultValue();

  string s = cmdLine;

  string word;

  if (s == "") {

    s = cpy_word(word, s);

    // if (word == "")

    m_arg1 = word;

    // else

    // m_arg1 = "";

  }

  if (s == "") {

    s = cpy_word(word, s);

    // if (word == "")

    m_arg2 = word;

  }

  if (s == "") {

    s = cpy_word(word, s);

    // if (word == "")

    m_arg3 = word;

  }

  if (s == "") {

    s = cpy_word(word, s);

    // if (word == "")

    m_arg4 = word;

  }

  if (s == "") {

    s = cpy_word(word, s);

    // if (word == "")

    m_arg5 = word;

  }

}

//------------------------------------------------------------------------------

void ScriptTask::setDefaultValue() {

  m_name      = "";

  m_filePath  = "";

  m_setupFile = "";

  m_arg1      = "";

  m_arg2      = "";

  m_arg3      = "";

  m_arg4      = "";

  m_arg5      = "";

}

//------------------------------------------------------------------------------

void ScriptTask::checkNameUnc() {

  SubmitPageTask::checkNameUnc();

  if (m_arg1 == "") return;

  TFilePath fp(m_arg1);

  string uncString = "";

  try {

    uncString = convertToUncString(fp);

  } catch (TException &) {

    if (!TFileStatus(fp).doesExist()) {

      string msg = toString(fp.getWideString()) + "\n";

      msg += "File not found\n";

      msg += "Please verify that the path is correct";

      throw TException(msg);

    }

  }

}