/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image 
#                        pour la Sant�)
# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
# Previous Authors : Laurent Guigues, Jean-Pierre Roux
# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
#
#  This software is governed by the CeCILL-B license under French law and 
#  abiding by the rules of distribution of free software. You can  use, 
#  modify and/ or redistribute the software under the terms of the CeCILL-B 
#  license as circulated by CEA, CNRS and INRIA at the following URL 
#  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
#  or in the file LICENSE.txt.
#
#  As a counterpart to the access to the source code and  rights to copy,
#  modify and redistribute granted by the license, users are provided only
#  with a limited warranty  and the software's author,  the holder of the
#  economic rights,  and the successive licensors  have only  limited
#  liability. 
#
#  The fact that you are presently reading this means that you have had
#  knowledge of the CeCILL-B license and that you accept its terms.
# ------------------------------------------------------------------------ 
 */

/*
 * modelCDMProject.cpp
 *
 *  Created on: 13/11/2012
 *      Author: Daniel Felipe Gonzalez Obando
 */

#include "modelCDMProject.h"

#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <ctime>

#include "CDMUtilities.h"
#include "creaWx.h"
#include "wx/dir.h"

modelCDMProject::modelCDMProject()
{
  std::cout << "in constructor1" << std::endl;
  this->appli = NULL;
  this->lib = NULL;
  this->CMakeLists = NULL;
}

modelCDMProject::modelCDMProject(
    const std::string& path,
    const std::string& name,
    const std::string& buildPath
)
{
  std::cout << "creating project: " + name + " in " + path + "\n";
  this->path = CDMUtilities::fixPath(path);
  //open makelists file
  std::string pathFixed(CDMUtilities::fixPath(path));

  std::string pathMakeLists = pathFixed + CDMUtilities::SLASH + "CMakeLists.txt";

  std::ifstream confFile;
  confFile.open((pathMakeLists).c_str());

  std::string word;
  while(confFile.is_open() && !confFile.eof())
    {
      //std::cout << "leyendo " << word << std::endl;
      //get project name
      std::getline(confFile,word,'(');
      std::vector<std::string> wordBits;
      CDMUtilities::splitter::split(wordBits,word," (\n",CDMUtilities::splitter::no_empties);

      if(wordBits[wordBits.size()-1] == "PROJECT")
        {
          std::getline(confFile,word,')');
          std::vector<std::string> nameBits;
          CDMUtilities::splitter::split(nameBits, word, " ", CDMUtilities::splitter::no_empties);

          this->name = this->nameProject = "";
          for (int i = 0; i < nameBits.size(); i++)
            {
              if(i != 0)
                this->name += " ";
              this->name += nameBits[i];
            }
          this->nameProject = this->name;

        }


      if(wordBits[wordBits.size()-1] == "SET")
        {
          //get project version
          std::getline(confFile,word,')');
          CDMUtilities::splitter::split(wordBits, word, " ", CDMUtilities::splitter::no_empties);
          if(wordBits[0] == "PROJECT_MAJOR_VERSION")
            {
              version = wordBits[1];
            }
          if(wordBits[0] == "PROJECT_MINOR_VERSION")
            {
              version += "." + wordBits[1];
            }
          if(wordBits[0] == "PROJECT_BUILD_VERSION")
            {
              version += "." + wordBits[1];
            }

          //get project versionDate
          if(wordBits[0] == "PROJECT_VERSION_DATE")
            {
              std::vector<std::string> versionBits;
              CDMUtilities::splitter::split(versionBits, wordBits[1], "\"", CDMUtilities::splitter::no_empties);
              versionDate = versionBits[0];
            }
          //get project buildPath

          if (buildPath != "")
            {
              this->buildPath = buildPath;
            }
          else
            {
              this->buildPath = this->path + "Bin";
            }
        }
    }
  confFile.close();

  this->type = wxDIR_DIRS;
  this->level = 0;

  this->children.clear();
  this->appli = NULL;
  this->lib = NULL;
  this->packages.clear();


  //check all folders
  wxDir dir(crea::std2wx((pathFixed).c_str()));
  if (dir.IsOpened())
    {
      wxString fileName;
      bool cont = dir.GetFirst(&fileName, wxEmptyString, wxDIR_DIRS);
      while (cont)
        {
          std::string stdfileName = crea::wx2std(fileName);

          //if appli, create appli
          if(stdfileName == "appli")
            {
              this->appli = new modelCDMAppli(pathFixed + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
              this->children.push_back(this->appli);
            }
          //if lib, create lib
          else if(stdfileName == "lib")
            {
              this->lib = new modelCDMLib(pathFixed + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
              this->children.push_back(this->lib);
            }
          //if package , create package
          else if(stdfileName.size() > 9 && stdfileName.substr(0,5) == "bbtk_" && stdfileName.substr(stdfileName.size()-4,4) == "_PKG")
            {
              modelCDMPackage* package = new modelCDMPackage(pathFixed + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
              this->packages.push_back(package);
              this->children.push_back(package);
            }
          //if is an unknown folder, create folder
          else
            {
              this->children.push_back(new modelCDMFolder(pathFixed + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1));
            }

          cont = dir.GetNext(&fileName);
        }

      cont = dir.GetFirst(&fileName, wxEmptyString, wxDIR_FILES);
      while (cont)
        {
          std::string stdfileName = crea::wx2std(fileName);

          //if CMakeLists, create CMakeLists
          if(stdfileName == "CMakeLists.txt")
            {
              this->CMakeLists = new modelCDMCMakeListsFile(pathFixed + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
              this->children.push_back(this->CMakeLists);
            }
          else
            {
              this->children.push_back(new modelCDMFile(pathFixed + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1));
            }
          //if is an unknown file, create file
          cont = dir.GetNext(&fileName);
        }
    }

  this->SortChildren();
  std::sort(this->packages.begin(), this->packages.end(), CompareNodeItem);

}

modelCDMProject::~modelCDMProject()
{
}

const std::string& modelCDMProject::GetNameProject() const
{
  return this->nameProject;
}

const std::string& modelCDMProject::GetVersion() const
{
  return this->version;
}

const std::string& modelCDMProject::GetVersionDate() const
{
  return this->versionDate;
}

const std::string& modelCDMProject::GetBuildPath() const
{
  return this->buildPath;
}

const std::vector<modelCDMPackage*>& modelCDMProject::GetPackages() const
{
  return this->packages;
}

modelCDMAppli* modelCDMProject::GetAppli() const
{
  return this->appli;
}

modelCDMLib* modelCDMProject::GetLib() const
{
  return this->lib;
}

bool modelCDMProject::SetVersion(const std::string& version, std::string*& result)
{

  std::vector<std::string> vers;
  CDMUtilities::splitter::split(vers, version, " .", CDMUtilities::splitter::no_empties);

  time_t now = time(0);
  tm* ltm = localtime(&now);

  std::stringstream date;
  date << ltm->tm_mday << "/" << 1 + ltm->tm_mon << "/" << 1900 + ltm->tm_year;

  //set name of library in CMakeLists inside copied folder
  std::string line;
  std::ifstream in((this->path + CDMUtilities::SLASH + "CMakeLists.txt").c_str());
  if( !in.is_open())
    {
      result = new std::string("CMakeLists.txt file failed to open.");
      return false;
    }
  std::ofstream out((this->path + CDMUtilities::SLASH + "CMakeLists.txt.tmp").c_str());
  if( !out.is_open())
    {
      result = new std::string("CMakeLists.txt.tmp file failed to open.");
      return false;
    }
  while (getline(in, line))
    {
      if(line.find("SET(PROJECT_MAJOR_VERSION") != std::string::npos)
        line = "SET(PROJECT_MAJOR_VERSION " + vers[0] + ")";
      else if(line.find("SET(PROJECT_MINOR_VERSION") != std::string::npos)
        line = "SET(PROJECT_MINOR_VERSION " + vers[1] + ")";
      else if(line.find("SET(PROJECT_BUILD_VERSION") != std::string::npos)
        line = "SET(PROJECT_BUILD_VERSION " + vers[2] + ")";
      else if(line.find("SET(PROJECT_VERSION_DATE") != std::string::npos)
        line = "SET(PROJECT_VERSION_DATE \"" + date.str() + "\")";
      out << line << std::endl;
    }
  in.close();
  out.close();
  //delete old file and rename new file
  std::string renameCommand = "mv \"" + this->path + CDMUtilities::SLASH + "CMakeLists.txt.tmp\" \"" + this->path + CDMUtilities::SLASH + "CMakeLists.txt\"";
  if(system(renameCommand.c_str()))
    {
      result = new std::string("An error occurred while running '" + renameCommand + "'.");
      return false;
    }

  this->version = vers[0] + "." + vers[1] + "." + vers[2];
  this->versionDate = date.str();
  return true;
}

bool modelCDMProject::SetBuildPath(const std::string& path, std::string*& result)
{
  if(path == "")
    {
      result = new std::string("The path cannot be empty");
      return false;
    }
  if(path == this->path)
    {
      result = new std::string("The path cannot be same as the project sources");
      return false;
    }
  this->buildPath = path;
  return true;
}

modelCDMIProjectTreeNode* modelCDMProject::CreatePackage(
    const std::string& name,
    std::string*& result,
    const std::string& authors,
    const std::string& authorsEmail,
    const std::string& description,
    const std::string& version
)
{
  //fixing input parameters
  std::vector<std::string> words;

  CDMUtilities::splitter::split(words,name," ",CDMUtilities::splitter::no_empties);
  std::string nameFixed = "";
  for (int i = 0; i < words.size(); i++)
    {
      nameFixed += words[i];
    }

  words.clear();
  CDMUtilities::splitter::split(words,authors," ",CDMUtilities::splitter::no_empties);
  std::string authorFixed;
  for (int i = 0; i < words.size(); i++)
    {
      authorFixed += words[i];
    }

  words.clear();
  std::string descriptionFixed;
  CDMUtilities::splitter::split(words,authorsEmail," ",CDMUtilities::splitter::no_empties);
  for (int i = 0; i < words.size(); i++)
    {
      descriptionFixed += words[i];
    }
  words.clear();
  CDMUtilities::splitter::split(words,description," ",CDMUtilities::splitter::no_empties);
  for (int i = 0; i < words.size(); i++)
    {
      descriptionFixed += "_" + words[i];
    }

  //call project to create package : use bbCreatePackage <path> <name> [author] [description]
  std::string creationCommand = "bbCreatePackage \"" + this->path + "\" \"" + nameFixed + "\" \"" + authorFixed + "\" \"" + descriptionFixed + "\"";
  //TODO: bbCreatePackage script always returning 0. It should return 1 or greater if any error
  if(system(creationCommand.c_str()))
    {
      result = new std::string("An error occurred while running '" + creationCommand + "'.");
      return NULL;
    }

  //add library to model
  modelCDMPackage* package = new modelCDMPackage(this->path + CDMUtilities::SLASH + "bbtk_" + nameFixed + "_PKG", "bbtk_" + nameFixed + "_PKG", this->level + 1);
  this->packages.push_back(package);
  this->children.push_back(package);

  //TODO: set package version

  this->SortChildren();

  result = new std::string(this->path + CDMUtilities::SLASH + name);
  return package;
}

modelCDMIProjectTreeNode* modelCDMProject::CreateLibrary(
    const std::string& name,
    std::string*& result,
    const std::string& path
)
{
  if(this->lib != NULL)
    {
      return this->lib->CreateLibrary(name, result);
    }
  result = new std::string("there is no lib folder in this project.");
  return NULL;
}

modelCDMIProjectTreeNode* modelCDMProject::CreateApplication(
    const std::string& name,
    std::string*& result,
    const std::string& path
)
{
  if(this->appli != NULL)
    {
      return this->appli->CreateApplication(name, result);
    }
  result = new std::string("there is no appli folder in this project.");
  return NULL;
}

modelCDMIProjectTreeNode* modelCDMProject::CreateBlackBox(
    const std::string& name,
    const std::string& package,
    const std::string& authors,
    const std::string& authorsEmail,
    const std::string& categories,
    const std::string& description
)
{
  //TODO: implement method
  return NULL;
}

bool modelCDMProject::OpenCMakeListsFile(std::string*& result)
{
  if (!CDMUtilities::openTextEditor(this->CMakeLists->GetPath()))
    return true;
  else
    {
      result = new std::string("Couldn't open CMakeLists file.");
      return false;
    }
}

const bool modelCDMProject::Refresh(std::string*& result)
{
  std::cout << "refreshing project" << std::endl;
  //open makelists file
  std::string pathMakeLists = this->path + CDMUtilities::SLASH + "CMakeLists.txt";

  std::ifstream confFile;
  confFile.open((pathMakeLists).c_str());

  std::string word;
  while(confFile.is_open() && !confFile.eof())
    {
      //std::cout << "leyendo " << word << std::endl;
      //get project name
      std::getline(confFile,word,'(');
      std::vector<std::string> wordBits;
      CDMUtilities::splitter::split(wordBits,word," (\n",CDMUtilities::splitter::no_empties);

      if(wordBits[wordBits.size()-1] == "PROJECT")
        {
          std::getline(confFile,word,')');
          std::vector<std::string> nameBits;
          CDMUtilities::splitter::split(nameBits, word, " ", CDMUtilities::splitter::no_empties);

          this->name = this->nameProject = "";
          for (int i = 0; i < nameBits.size(); i++)
            {
              if(i != 0)
                this->name += " ";
              this->name += nameBits[i];
            }
          this->nameProject = this->name;

        }


      if(wordBits[wordBits.size()-1] == "SET")
        {
          //get project version
          std::getline(confFile,word,')');
          CDMUtilities::splitter::split(wordBits, word, " ", CDMUtilities::splitter::no_empties);
          if(wordBits[0] == "PROJECT_MAJOR_VERSION")
            {
              version = wordBits[1];
            }
          if(wordBits[0] == "PROJECT_MINOR_VERSION")
            {
              version += "." + wordBits[1];
            }
          if(wordBits[0] == "PROJECT_BUILD_VERSION")
            {
              version += "." + wordBits[1];
            }

          //get project versionDate
          if(wordBits[0] == "PROJECT_VERSION_DATE")
            {
              std::vector<std::string> versionBits;
              CDMUtilities::splitter::split(versionBits, wordBits[1], "\"", CDMUtilities::splitter::no_empties);
              versionDate = versionBits[0];
            }
        }
    }
  confFile.close();

  this->type = wxDIR_DIRS;
  this->level = 0;

  std::vector<bool> checked(this->children.size(), false);
  std::vector<bool> checkedPackages(this->packages.size(), false);

  //check all folders
  wxDir dir(crea::std2wx((this->path).c_str()));
  if (dir.IsOpened())
    {
      wxString fileName;
      bool cont = dir.GetFirst(&fileName, wxEmptyString, wxDIR_DIRS);
      while (cont)
        {
          std::string stdfileName = crea::wx2std(fileName);

          //if appli, create appli
          if(stdfileName == "appli")
            {
              if (this->appli == NULL)
                {
                  this->appli = new modelCDMAppli(this->path + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
                  this->children.push_back(this->appli);
                }
              else
                {
                  int pos = std::find(this->children.begin(), this->children.end(), this->appli) - this->children.begin();
                  checked[pos] = true;
                  if(!this->appli->Refresh(result))
                    return false;
                }
            }
          //if lib, create lib
          else if(stdfileName == "lib")
            {
              if (this->lib == NULL)
                {
                  this->lib = new modelCDMLib(this->path + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
                  this->children.push_back(this->lib);
                }
              else
                {
                  int pos = std::find(this->children.begin(), this->children.end(), this->lib) - this->children.begin();
                  checked[pos] = true;
                  if(!this->lib->Refresh(result))
                    return false;
                }

            }
          //if package , create package
          else if(stdfileName.size() > 9 && stdfileName.substr(0,5) == "bbtk_" && stdfileName.substr(stdfileName.size()-4,4) == "_PKG")
            {
              bool found = false;
              for (int i = 0; !found && i < this->packages.size(); i++)
                {
                  if (this->packages[i]->GetName() == stdfileName)
                    {
                      found = true;
                      int pos = std::find(this->children.begin(), this->children.end(), this->packages[i]) - this->children.begin();
                      checked[pos] = true;
                      checkedPackages[i] = true;
                      if(!this->packages[i]->Refresh(result))
                        return false;
                    }
                }
              if(!found)
                {
                  modelCDMPackage* package = new modelCDMPackage(this->path + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
                  this->packages.push_back(package);
                  this->children.push_back(package);
                }

            }
          //if is an unknown folder, create folder
          else
            {
              bool found = false;
              for (int i = 0; !found && i < this->children.size(); i++)
                {
                  if (this->children[i]->GetName() == stdfileName)
                    {
                      found = true;
                      checked[i] = true;
                      if(!this->children[i]->Refresh(result))
                        return false;
                    }
                }

              if(!found)
                {
                  modelCDMFolder* folder = new modelCDMFolder(this->path + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
                  this->children.push_back(folder);
                }
            }

          cont = dir.GetNext(&fileName);
        }

      cont = dir.GetFirst(&fileName, wxEmptyString, wxDIR_FILES);
      while (cont)
        {
          std::string stdfileName = crea::wx2std(fileName);

          //if CMakeLists, create CMakeLists
          if(stdfileName == "CMakeLists.txt")
            {
              if (this->CMakeLists == NULL)
                {
                  this->CMakeLists = new modelCDMCMakeListsFile(this->path + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
                  this->children.push_back(this->CMakeLists);
                }
              else
                {
                  int pos = std::find(this->children.begin(), this->children.end(), this->CMakeLists) - this->children.begin();
                  checked[pos] = true;
                  if(!this->CMakeLists->Refresh(result))
                    return false;
                }
            }
          //if is an unknown file, create file
          else
            {
              bool found = false;
              for (int i = 0; !found && i < this->children.size(); i++)
                {
                  if (this->children[i]->GetName() == stdfileName)
                    {
                      found = true;
                      checked[i] = true;
                      if(!this->children[i]->Refresh(result))
                        return false;
                    }
                }

              if(!found)
                {
                  modelCDMFile* file = new modelCDMFile(this->path + CDMUtilities::SLASH + stdfileName, stdfileName, this->level + 1);
                  this->children.push_back(file);
                }
            }

          cont = dir.GetNext(&fileName);
        }
    }

  for (int i = 0; i < checkedPackages.size(); i++)
    {
      if(!checkedPackages[i])
        {
          this->packages.erase(this->packages.begin()+i);
          checkedPackages.erase(checkedPackages.begin()+i);
          i--;
        }
    }
  for (int i = 0; i < checked.size(); i++)
    {
      if(!checked[i])
        {
          delete this->children[i];
          this->children.erase(this->children.begin()+i);
          checked.erase(checked.begin()+i);
          i--;
        }
    }

  this->SortChildren();
  std::sort(this->packages.begin(), this->packages.end(), CompareNodeItem);
  return true;
}

bool modelCDMProject::ConfigureBuild(std::string*& result)
{
  //TODO: adjust for windows and mac
#ifdef _WIN32
  // ------ Windows
#elif __APPLE__
  // ------ Apple
#else
  // ------ Linux
  //open binary folder
  wxDir dir(crea::std2wx((this->buildPath).c_str()));

  //if folder doesn't exist then create it
  if (!dir.IsOpened())
    {
      //create command line to create folder
      std::string createComm = "mkdir \"" + this->buildPath + "\"";
      //execute creation command
      if (system(createComm.c_str()))
        {
          //if there was an error then report it
          result = new std::string("There was an error creating the build path: \"" + this->buildPath + "\"");
          return false;
        }
    }
  //create command line to execute ccmake
  //TODO:: adjust for different Linux distributions
  std::string confComm = "gnome-terminal --tab --working-directory=\"" + this->buildPath + "\" -e \"ccmake '" + this->path + "'\"";
  //execute command
  if(CDMUtilities::openTerminal(confComm))
    {
      //if there was an error then report it
      result = new std::string("There was an error opening the configuration tool in the desired place.");
      return false;
    }
#endif
  return true;
}

bool modelCDMProject::Build(std::string*& result)
{
  //TODO: adjust for windows and mac
#ifdef _WIN32
  // ------ Windows
#elif __APPLE__
  // ------ Apple
#else
  // ------ Linux
  //open binary folder
  wxDir dir(crea::std2wx((this->buildPath).c_str()));

  //if binary folder can't be opened then return false
  if (!dir.IsOpened())
    {
      result = new std::string("The build path could not be opened. Make sure to configure the project before compiling it");
      return false;
    }
  //create make command
  std::string makeComm = "make -C \"" + this->buildPath + "\" > \"" + this->buildPath + CDMUtilities::SLASH + "building.log\" 2>&1";
  std::cout << "executing '" << makeComm << "'" << std::endl;
  //execute make command
  if(system(makeComm.c_str()))
    {
      //if there was an error then report it
      result = new std::string("There was an error compiling the project, please check the \"building.log\" file located in the build folder to read more about the problem.");
      return false;
    }
#endif
  return true;
}

bool modelCDMProject::Connect(std::string*& result)
{
  //TODO: adjust for windows and mac
  #ifdef _WIN32
    // ------ Windows
  #elif __APPLE__
    // ------ Apple
  #else
    // ------ Linux
    //open binary folder
    wxDir dir(crea::std2wx((this->buildPath).c_str()));

    //if binary folder can't be opened then return false
    if (!dir.IsOpened())
      {
        result = new std::string("The build path could not be opened. Make sure to configure the project before compiling it");
        return false;
      }
    //create plug command
    std::string plugComm = "bbPlugPackage \"" + this->buildPath + "\" > \"" + this->buildPath + CDMUtilities::SLASH + "plugging.log\" 2>&1";
    std::cout << "executing '" << plugComm << "'" << std::endl;
    //execute plug command
    if(system(plugComm.c_str()))
      {
        //if there was an error then report it
        result = new std::string("There was an error plugging the packages of the project, please check the \"plugging.log\" file located in the build folder to read more about the problem.");
        return false;
      }
  #endif
    return true;
}