#include "texternfx.h"
#include "tsystem.h"
#include "tdoubleparam.h"
#include "timage_io.h"
//#include "tfx.h"
#include "trasterfx.h"
//#include "tsystem.h"
//#include "tparamcontainer.h"
#include "tfxparam.h"
#include "tstream.h"

namespace {

TFilePath getExternFxPath() {
  return TSystem::getBinDir() + "plugins" + "externFxs";
}
}

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

// not implemented yet
void TExternFx::getNames(std::vector<std::string> &names) {}

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

TExternFx *TExternFx::create(std::string name) {
  TExternalProgramFx *fx = new TExternalProgramFx(name);
  return fx;
}

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

TExternalProgramFx::TExternalProgramFx(std::string name)
    : m_externFxName(name) {
  initialize(name);
  setName(L"ExternalProgramFx");
  //    addInputPort("input2", m_input2);
}

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

TExternalProgramFx::TExternalProgramFx() : m_externFxName() {
  setName(L"ExternalProgramFx");
  //    addInputPort("input2", m_input2);
}

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

TExternalProgramFx::~TExternalProgramFx() {}

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

void TExternalProgramFx::initialize(std::string name) {
  TFilePath fp = getExternFxPath() + (name + ".xml");
  TIStream is(fp);
  if (!is) return;

  std::string tagName;
  if (!is.matchTag(tagName) || tagName != "externFx") return;

  try {
    while (is.matchTag(tagName)) {
      if (tagName == "executable") {
        TFilePath executable = TFilePath(is.getTagAttribute("path"));
        std::string args     = is.getTagAttribute("args");
        if (executable == TFilePath())
          throw TException("missing executable path");
        if (args == "") throw TException("missing args string");
        setExecutable(executable, args);
      } else if (tagName == "inport" || tagName == "outport") {
        std::string portName = is.getTagAttribute("name");
        std::string ext      = is.getTagAttribute("ext");
        if (portName == "") throw TException("missing port name");
        if (ext == "") throw TException("missing port ext");
        addPort(portName, ext, tagName == "inport");
      } else if (tagName == "param") {
        std::string paramName = is.getTagAttribute("name");
        if (paramName == "") throw TException("missing param name");
        std::string type = is.getTagAttribute("type");
        if (type == "") throw TException("missing param type");
        if (type != "double")
          throw TException("param type not yet implemented");
        TDoubleParamP param = new TDoubleParam();
        param->setName(paramName);
        m_params.push_back(param);
      } else
        throw TException("unexpected tag " + tagName);
    }
    is.closeChild();

    for (int i = 0; i < (int)m_params.size(); i++)
      bindParam(this, m_params[i]->getName(), m_params[i]);

  } catch (...) {
  }
}

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

void TExternalProgramFx::addPort(std::string portName, std::string ext,
                                 bool isInput) {
  if (isInput) {
    TRasterFxPort *port = new TRasterFxPort();
    m_ports[portName]   = Port(portName, ext, port);
    addInputPort(portName, *port);
  } else
    m_ports[portName] = Port(portName, ext, 0);
}

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

// void TExternalProgramFx::addParam(string paramName, const TParamP &param)
//{
//  m_params[paramName] = param;
//  TFx::addParam(paramName, param);
//}

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

TFx *TExternalProgramFx::clone(bool recursive) const {
  TExternalProgramFx *fx =
      dynamic_cast<TExternalProgramFx *>(TExternFx::create(m_externFxName));
  assert(fx);
  // new TExternalProgramFx();
  // fx->setExecutable(m_executablePath, m_args);

  // copia della time region
  fx->setActiveTimeRegion(getActiveTimeRegion());
  // fx->m_imp->m_activeTimeRegion = m_imp->m_activeTimeRegion;

  fx->getParams()->copy(getParams());

  assert(getInputPortCount() == fx->getInputPortCount());

  // std::map<std::string, Port>::const_iterator j;
  // for(j=m_ports.begin(); j!=m_ports.end(); ++j)
  //  fx->addPort(j->first, j->second.m_ext, j->second.m_port != 0);

  // copia ricorsiva sulle porte
  if (recursive) {
    for (int i = 0; i < getInputPortCount(); ++i) {
      TFxPort *port = getInputPort(i);
      if (port->getFx())
        fx->connect(getInputPortName(i), port->getFx()->clone(true));
    }
  }

  // std::map<std::string, TParamP>::const_iterator j;
  // for(j=m_params.begin(); j!=m_params.end(); ++j)
  //  fx->addParam(j->first, j->second->clone());

  return fx;
}

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

bool TExternalProgramFx::doGetBBox(double frame, TRectD &bBox,
                                   const TRenderSettings &info) {
  // bBox = TRectD(-30,-30,30,30);
  //  return true;

  std::map<std::string, Port>::const_iterator portIt;
  for (portIt = m_ports.begin(); portIt != m_ports.end(); ++portIt) {
    if (portIt->second.m_port != 0) {
      TRasterFxPort *tmp;
      tmp = portIt->second.m_port;
      if (tmp->isConnected()) {
        TRectD tmpbBox;
        (*tmp)->doGetBBox(frame, tmpbBox, info);
        bBox += tmpbBox;
      }
    }
  }

  if (bBox.isEmpty()) {
    bBox = TRectD();
    return false;
  } else
    return true;
  /*
if(m_input1.isConnected() || m_input2.isConnected())
{
bool ret = m_input1->doGetBBox(frame, bBox) || m_input1->doGetBBox(frame, bBox);
return ret;
}
else
{
bBox = TRectD();
return false;
}
*/
}

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

void TExternalProgramFx::doCompute(TTile &tile, double frame,
                                   const TRenderSettings &ri) {
  TRaster32P ras = tile.getRaster();
  if (!ras) return;
  std::string args           = m_args;
  std::string executablePath = ::to_string(m_executablePath);
  std::map<std::string, TFilePath> tmpFiles;  // portname --> file
  TFilePath outputTmpFile;

  std::map<std::string, Port>::const_iterator portIt;
  for (portIt = m_ports.begin(); portIt != m_ports.end(); ++portIt) {
    TFilePath fp            = TSystem::getUniqueFile("externfx");
    fp                      = fp.withType(portIt->second.m_ext);
    tmpFiles[portIt->first] = fp;
    if (portIt->second.m_port == 0)  // solo una porta e' di output
      outputTmpFile = fp;
    else {
      TRasterFxPort *tmp;
      tmp = portIt->second.m_port;
      if (tmp->isConnected()) {
        (*tmp)->compute(tile, frame, ri);
        TImageWriter::save(fp, ras);
      }
    }
  }

  // args e' della forma "$src $ctrl -o $out -v $value"
  // sostituisco le variabili
  int i = 0;
  for (;;) {
    i = args.find('$', i);
    if (i == (int)std::string::npos) break;
    int j   = i + 1;
    int len = args.length();
    while (j < len && isalnum(args[j])) j++;
    // un '$' non seguito da caratteri alfanumerici va ignorato
    if (j == i + 1) {
      // la sequenza '$$' diventa '$'
      if (j < len && args[j] == '$') args.replace(i, 2, "$");
      i++;
      continue;
    }
    // ho trovato una variabile
    int m            = j - i - 1;
    std::string name = args.substr(i + 1, m);
    // calcolo il valore.
    std::string value;

    std::map<std::string, TFilePath>::const_iterator it;
    it = tmpFiles.find(name);
    if (it != tmpFiles.end()) {
      // e' una porta. il valore e' il nome del
      // file temporaneo
      value = "\"" + ::to_string(it->second.getWideString()) + "\"";
    } else {
      // e' un parametro
      // se il nome non viene riconosciuto sostituisco la stringa nulla
      TDoubleParamP param = TParamP(getParams()->getParam(name));
      if (param) value    = std::to_string(param->getValue(frame));
    }

    args.replace(i, m + 1, value);
  }
  args = " " + args;  // aggiungo uno spazio per sicurezza
  // ofstream os("C:\\temp\\butta.txt");
  // os << args << endl;

  // bisognerebbe calcolare le immagini dalla/e porta/e di input
  // scrivere il/i valore/i nei files temporanei/o
  // chiamare "m_executablePath args"
  // e leggere l'immagine scritta in outputTmpFile
  // poi cancellare tutto
  std::string expandedargs;
  char buffer[1024];
#ifdef _WIN32
  ExpandEnvironmentStrings(args.c_str(), buffer, 1024);

  STARTUPINFO si;
  PROCESS_INFORMATION pinfo;

  GetStartupInfo(&si);

  BOOL ret = CreateProcess(
      (char *)executablePath.c_str(),           // name of executable module
      buffer,                                   // command line string
      NULL,                                     // SD
      NULL,                                     // SD
      TRUE,                                     // handle inheritance option
      CREATE_NO_WINDOW, /*CREATE_NEW_CONSOLE*/  // creation flags
      NULL,                                     // new environment block
      NULL,                                     // current directory name
      &si,                                      // startup information
      &pinfo                                    // process information
      );

  if (!ret) DWORD err = GetLastError();

  // aspetta che il processo termini
  WaitForSingleObject(pinfo.hProcess, INFINITE);

  DWORD exitCode;
  ret = GetExitCodeProcess(pinfo.hProcess,  // handle to the process
                           &exitCode);      // termination status

#else
  std::string cmdline = executablePath + buffer;
  //    int exitCode =
  system(cmdline.c_str());
#endif
  /*
string name = m_executablePath.getName();
TPixel32 color;
if(name == "saturate") color = TPixel32::Magenta;
else if(name == "over") color = TPixel32::Green;
else color = TPixel32::Red;
for(int iy=0;iy<ras->getLy();iy++)
{
TPixel32 *pix = ras->pixels(iy);
TPixel32 *endPix = pix + ras->getLx();
double x = tile.m_pos.x;
double y = tile.m_pos.y + iy;
while(pix<endPix)
 {
  if(x*x+y*y<900) *pix = color;
  else *pix = TPixel32(0,0,0,0);
  ++pix;
  x+=1.0;
 }
}
*/

  try {
    TRasterP ras = tile.getRaster();
    TImageReader::load(outputTmpFile, ras);
  } catch (...) {
  }

  // butto i file temporanei creati
  std::map<std::string, TFilePath>::const_iterator fileIt;
  for (fileIt = tmpFiles.begin(); fileIt != tmpFiles.end(); ++fileIt) {
    if (TFileStatus(fileIt->second).doesExist() == true) try {
        TSystem::deleteFile(fileIt->second);
      } catch (...) {
      }
  }
  if (TFileStatus(outputTmpFile).doesExist() == true) try {
      TSystem::deleteFile(outputTmpFile);
    } catch (...) {
    }
}

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

void TExternalProgramFx::loadData(TIStream &is) {
  std::string tagName;
  while (is.openChild(tagName)) {
    if (tagName == "path") {
      is >> m_executablePath;
    } else if (tagName == "args") {
      is >> m_args;
    } else if (tagName == "name") {
      is >> m_externFxName;
      // initialize(m_externFxName);
    } else if (tagName == "params") {
      while (is.matchTag(tagName)) {
        if (tagName == "param") {
          // assert(0);
          std::string paramName = is.getTagAttribute("name");
          TDoubleParamP param   = new TDoubleParam();
          param->setName(paramName);
          m_params.push_back(param);
        } else
          throw TException("unexpected tag " + tagName);
      }
      for (int i = 0; i < (int)m_params.size(); i++)
        bindParam(this, m_params[i]->getName(), m_params[i]);
    } else if (tagName == "ports") {
      while (is.matchTag(tagName)) {
        if (tagName == "port") {
          std::string name = is.getTagAttribute("name");
          std::string ext  = is.getTagAttribute("ext");
          addPort(name, ext, true);
        } else if (tagName == "outport") {
          std::string name = is.getTagAttribute("name");
          std::string ext  = is.getTagAttribute("ext");
          addPort(name, ext, false);
        } else
          throw TException("unexpected tag " + tagName);
      }
    } else if (tagName == "super") {
      TExternFx::loadData(is);
    } else
      throw TException("unexpected tag " + tagName);
    is.closeChild();
  }
}

void TExternalProgramFx::saveData(TOStream &os) {
  os.child("name") << m_externFxName;
  os.child("path") << m_executablePath;
  os.child("args") << m_args;
  os.openChild("params");
  for (int i = 0; i < getParams()->getParamCount(); i++) {
    std::map<std::string, std::string> attr;
    attr["name"] = getParams()->getParamName(i);
    attr["type"] = "double";
    os.openCloseChild("param", attr);
  }
  os.closeChild();
  os.openChild("ports");
  std::map<std::string, Port>::iterator portIt;
  for (portIt = m_ports.begin(); portIt != m_ports.end(); ++portIt) {
    std::map<std::string, std::string> attr;
    attr["name"]        = portIt->second.m_name;
    attr["ext"]         = portIt->second.m_ext;
    std::string tagName = portIt->second.m_port == 0 ? "outport" : "port";
    os.openCloseChild(tagName, attr);
  }
  os.closeChild();
  os.openChild("super");
  TExternFx::saveData(os);
  os.closeChild();
}

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

#ifdef CICCIO
//-------------------------------------------------------------------

void ExternalProgramFx::doCompute(TTile &tile, double frame,
                                  const TRenderSettings &ri) {
  if (!m_input1.isConnected() || !m_input2.isConnected()) {
    tile.getRaster()->clear();
    return;
  }
  std::string name1("C:\\temp\\uno..tif");
  std::string name2("C:\\temp\\due..tif");
  std::string outname("C:\\temp\\outfile.0001.jpg");
  std::string program("C:\\temp\\xdissolve.exe");
  std::string extension(".jpg");
  TFilePath programpath(program);

  m_input1->compute(tile, frame, ri);
  TFilePath fname1(name1);
  TFilePath fname2(name2);
  std::string tmp1 = fname1.getName() + extension;
  std::string tmp2 = fname2.getName() + extension;

  TFilePath tmpname1(fname1.getParentDir() + tmp1);
  TFilePath tmpname2(fname2.getParentDir() + tmp2);
  TFilePath out(outname);
  TImageWriter::save(tmpname1, tile.getRaster());
  m_input2->compute(tile, frame, ri);
  TImageWriter::save(tmpname2, tile.getRaster());

  std::string arglist = " -range1 1 1 -start2 1 -startout 1 ";
  arglist += toString(tmpname1.getWideString());
  arglist += " " + toString(tmpname2.getWideString());
  arglist += " " + outname;
  std::string cmdline = program + arglist;

#ifdef _WIN32
  STARTUPINFO si;
  PROCESS_INFORMATION pinfo;

  GetStartupInfo(&si);

  BOOL ret =
      CreateProcess(NULL,                     // name of executable module
                    (char *)cmdline.c_str(),  // command line string
                    NULL,                     // SD
                    NULL,                     // SD
                    TRUE,                     // handle inheritance option
                    CREATE_NO_WINDOW, /*CREATE_NEW_CONSOLE*/  // creation flags
                    NULL,   // new environment block
                    NULL,   // current directory name
                    &si,    // startup information
                    &pinfo  // process information
                    );

  if (!ret) DWORD err = GetLastError();

  // aspetta che il processo termini
  WaitForSingleObject(pinfo.hProcess, INFINITE);

  DWORD exitCode;
  ret = GetExitCodeProcess(pinfo.hProcess,  // handle to the process
                           &exitCode);      // termination status

#else
  int exitCode = system(cmdline.c_str());
#endif
  TImageReader::load(out, tile.getRaster());

  TSystem::deleteFile(tmpname1);
  TSystem::deleteFile(tmpname2);
  TSystem::deleteFile(out);
}

FX_PLUGIN_IDENTIFIER(ExternalProgramFx, "externalProgramFx");
* /

#endif
    FX_IDENTIFIER(TExternalProgramFx, "externalProgramFx")