#include "toonz/sceneresources.h"

#include "toonz/toonzscene.h"

#include "toonz/tproject.h"

#include "toonz/levelset.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshpalettelevel.h"

#include "toonz/levelproperties.h"

#include "toonz/txshsoundlevel.h"

#include "toonz/namebuilder.h"

#include "toonz/childstack.h"

#include "toonz/txsheet.h"

#include "toonz/preferences.h"

#include "tpalette.h"

#include "tconvert.h"

#include "tlogger.h"

#include "tsystem.h"

namespace {

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

// se path e' della forma +folder/<oldsavepath>/name.type</oldsavepath>

// allora sostituisce oldSavePath con newSavePath e ritorna true

bool changeSavePath(TFilePath &path, TFilePath oldSavePath,

                    TFilePath newSavePath) {

  if (oldSavePath == newSavePath) return false;

  TFilePath fp = path.getParentDir();

  std::wstring head;

  TFilePath tail;

  fp.split(head, tail);

  if (head != L"" && tail == oldSavePath) {

    path = path.withParentDir(TFilePath(head) + newSavePath);

    return true;

  } else

    return false;

}

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

// From ../../../filename#type.psd to ../../../filename.psd

TFilePath restorePsdPath(const TFilePath &fp) {

  QString path = QString::fromStdWString(fp.getWideString());

  if (fp.getType() != "psd" || !path.contains("#")) return fp;

  int from = path.indexOf("#");

  int to   = path.lastIndexOf(".");

  path.remove(from, to - from);

  return TFilePath(path.toStdWString());

}

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

bool makePathUnique(ToonzScene *scene, TFilePath &path) {

  std::wstring name = path.getWideName();

  int id            = 2;

  int i             = name.length() - 1;

  int num = 0, p = 1;

  while (i >= 0 && L'0' <= name[i] && name[i] <= L'9') {

    num += p * (name[i] - L'0');

    p *= 10;

    i--;

  }

  if (i >= 0 && name[i] == L'_') {

    id   = num + 1;

    name = name.substr(0, i);

  }

  bool ret = false;

  while (TSystem::doesExistFileOrLevel(scene->decodeFilePath(path))) {

    ret  = true;

    path = path.withName(name + L"_" + std::to_wstring(id));

    id++;

  }

  return ret;

}

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

bool getCollectedPath(ToonzScene *scene, TFilePath &path) {

  if (!path.isAbsolute() || path.getWideString()[0] == L'+') return false;

  TFilePath collectedPath = scene->getImportedLevelPath(path);

  if (path == collectedPath) return false;

  TFilePath actualCollectedPath = scene->decodeFilePath(collectedPath);

  if (makePathUnique(scene, actualCollectedPath))

    collectedPath = collectedPath.withName(actualCollectedPath.getName());

  path = collectedPath;

  return true;

}

}  // namespace

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

//

// ResourceImportStrategy

//

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

ResourceImportStrategy::ResourceImportStrategy(int strategy)

    : m_childFolderEnabled(false), m_strategy(strategy) {

  setChildFolderEnabled(Preferences::instance()->isSubsceneFolderEnabled());

}

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

TFilePath ResourceImportStrategy::process(ToonzScene *scene,

                                          ToonzScene *srcScene,

                                          TFilePath srcPath) {

  TFilePath srcActualPath = srcScene->decodeFilePath(srcPath);

  if (!scene->isExternPath(srcActualPath) || m_strategy == DONT_IMPORT)

    return srcPath;

  TFilePath dstPath;

  if (srcPath.getWideString().find(L'+') == 0)

    dstPath = srcPath;

  else

    dstPath               = scene->getImportedLevelPath(srcPath);

  TFilePath actualDstPath = scene->decodeFilePath(dstPath);

  assert(actualDstPath != TFilePath());

  if (m_strategy == IMPORT_AND_OVERWRITE) {

    // bool overwritten = false;

    if (TSystem::doesExistFileOrLevel(actualDstPath)) {

      TSystem::removeFileOrLevel(actualDstPath);

      //  overwritten = true;

    }

    if (TSystem::doesExistFileOrLevel(srcPath))

      TXshSimpleLevel::copyFiles(actualDstPath, srcPath);

    return dstPath;

  } else if (m_strategy == IMPORT_AND_RENAME) {

    std::wstring levelName    = srcPath.getWideName();

    TLevelSet *parentLevelSet = scene->getLevelSet();

    NameModifier nm(levelName);

    std::wstring newName;

    for (;;) {

      newName = nm.getNext();

      if (!parentLevelSet->hasLevel(newName)) break;

    }

    dstPath       = dstPath.withName(newName);

    actualDstPath = scene->decodeFilePath(dstPath);

    if (TSystem::doesExistFileOrLevel(actualDstPath))

      TSystem::removeFileOrLevel(actualDstPath);

    if (TSystem::doesExistFileOrLevel(srcActualPath)) {

      TXshSimpleLevel::copyFiles(actualDstPath, srcActualPath);

    }

    return dstPath;

  }

  return srcPath;

}

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

//

// SceneResource

//

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

SceneResource::SceneResource(ToonzScene *scene)

    : m_scene(scene)

    , m_untitledScene(scene->isUntitled())

    , m_oldSavePath(scene->getSavePath()) {}

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

SceneResource::~SceneResource() {}

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

void SceneResource::updatePath(TFilePath &fp) {

  if (m_untitledScene)

    changeSavePath(fp, m_oldSavePath, m_scene->getSavePath());

}

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

//

// SceneLevel

//

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

SceneLevel::SceneLevel(ToonzScene *scene, TXshSimpleLevel *sl)

    : SceneResource(scene)

    , m_sl(sl)

    , m_oldPath(sl->getPath())

    , m_oldActualPath(scene->decodeFilePath(sl->getPath()))

    , m_oldScannedPath(sl->getScannedPath())

    , m_oldRefImgPath()

    , m_oldActualRefImgPath() {

  if (m_oldScannedPath != TFilePath())

    m_oldActualScannedPath = m_scene->decodeFilePath(m_oldScannedPath);

  if ((sl->getPath().getType() == "tlv" || sl->getPath().getType() == "pli") &&

      sl->getPalette()) {

    m_oldRefImgPath       = sl->getPalette()->getRefImgPath();

    m_oldActualRefImgPath = m_scene->decodeFilePath(m_oldRefImgPath);

  }

}

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

void SceneLevel::save() {

  TFilePath fp = m_oldPath;

  SceneResource::updatePath(fp);

  TFilePath actualFp      = m_scene->decodeFilePath(fp);

  actualFp                = restorePsdPath(actualFp);

  TFilePath oldActualPath = restorePsdPath(m_oldActualPath);

  assert(actualFp.getWideString() == L"" ||

         actualFp.getWideString()[0] != L'+');

  if (actualFp != oldActualPath ||

      !TSystem::doesExistFileOrLevel(oldActualPath) ||

      m_sl->getProperties()->getDirtyFlag() ||

      (m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag())) {

    try {

      TSystem::touchParentDir(actualFp);

      if (actualFp != oldActualPath &&

          TSystem::doesExistFileOrLevel(oldActualPath) &&

          m_sl->getProperties()->getDirtyFlag() == false &&

          (!m_sl->getPalette() ||

           (m_sl->getPalette() &&

            m_sl->getPalette()->getDirtyFlag() == false))) {

        try {

          TXshSimpleLevel::copyFiles(actualFp, oldActualPath);

        } catch (...) {

        }

        // Must NOT KEEP FRAMES, it generate a level frames bind necessary to

        // imageBuilder path refresh.

        m_sl->setPath(fp, false);

      } else {

        m_sl->save(actualFp, oldActualPath);

        if ((actualFp.getType() == "tlv" || actualFp.getType() == "pli") &&

            actualFp != oldActualPath && m_oldRefImgPath != TFilePath()) {

          // Devo preoccuparmi dell'eventuale livello colormodel

          TFilePath actualRefImagPath =

              m_scene->decodeFilePath(m_oldRefImgPath);

          TFilePath actualRefImagPathTpl = actualRefImagPath.withType("tpl");

          TFilePath oldRefImagPathTpl = m_oldActualRefImgPath.withType("tpl");

          TSystem::copyFile(actualRefImagPath, m_oldActualRefImgPath);

          if (actualRefImagPath.getType() == "tlv")

            TSystem::copyFile(actualRefImagPathTpl, oldRefImagPathTpl);

        }

        if (actualFp.getType() == "tif" || actualFp.getType() == "tiff" ||

            actualFp.getType() == "tga" || actualFp.getType() == "tzi") {

          TFilePath clnin = oldActualPath.withNoFrame().withType("cln");

          if (TSystem::doesExistFileOrLevel(clnin))

            TSystem::copyFile(actualFp.withNoFrame().withType("cln"), clnin);

        }

      }

      // Se il livello e' tlv verifico se esiste il corrispondente unpainted ed

      // in caso affermativo lo copio.

      // Questo controllo viene fatto qui e non nella copia o nel salvataggio

      // del livello perche' in generale

      // non si vuole che il livello unpainted venga copiato con il livello.

      if (actualFp.getType() == "tlv") {

        TFilePath oldUnpaintedLevelPath =

            oldActualPath.getParentDir() + "nopaint\\" +

            TFilePath(oldActualPath.getName() + "_np." +

                      oldActualPath.getType());

        TFilePath unpaintedLevelPath =

            actualFp.getParentDir() + "nopaint\\" +

            TFilePath(actualFp.getName() + "_np." + actualFp.getType());

        if (TSystem::doesExistFileOrLevel(oldUnpaintedLevelPath) &&

            !TSystem::doesExistFileOrLevel(unpaintedLevelPath) &&

            TSystem::touchParentDir(unpaintedLevelPath))

          TSystem::copyFile(unpaintedLevelPath, oldUnpaintedLevelPath);

        TFilePath oldUnpaintedPalettePath =

            oldUnpaintedLevelPath.withType("tpl");

        TFilePath unpaintedPalettePath = unpaintedLevelPath.withType("tpl");

        if (TSystem::doesExistFileOrLevel(oldUnpaintedPalettePath) &&

            !TSystem::doesExistFileOrLevel(unpaintedPalettePath) &&

            TSystem::touchParentDir(unpaintedPalettePath))

          TSystem::copyFile(unpaintedPalettePath, oldUnpaintedPalettePath);

      }

    } catch (...) {

    }

  }

  fp = m_oldScannedPath;

  if (fp != TFilePath()) {

    SceneResource::updatePath(fp);

    actualFp = m_scene->decodeFilePath(fp);

    if (actualFp != m_oldActualScannedPath &&

        TSystem::doesExistFileOrLevel(m_oldActualScannedPath)) {

      try {

        TSystem::touchParentDir(actualFp);

        TSystem::copyFileOrLevel_throw(actualFp, m_oldActualScannedPath);

        m_sl->clearFrames();

        m_sl->load();

      } catch (...) {

      }

    }

  }

}

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

void SceneLevel::updatePath() {

  if (!m_untitledScene) return;

  TFilePath fp = m_oldPath;

  SceneResource::updatePath(fp);

  m_sl->setPath(fp, true);

  fp = m_oldScannedPath;

  SceneResource::updatePath(fp);

  m_sl->setScannedPath(fp);

}

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

void SceneLevel::rollbackPath() {

  if (!m_untitledScene) return;

  m_sl->setPath(m_oldPath, true);

  m_sl->setScannedPath(m_oldScannedPath);

}

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

bool SceneLevel::isDirty() {

  if (m_sl->getProperties()->getDirtyFlag() ||

      (m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag()))

    return true;

  else

    return false;

}

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

QString SceneLevel::getResourceName() {

  QString string;

  bool levelIsDirty = false;

  if (m_sl->getProperties()->getDirtyFlag()) {

    string += QString::fromStdString(m_sl->getPath().getLevelName());

    levelIsDirty = true;

  }

  if (m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag()) {

    if (levelIsDirty) string += " and ";

    if (m_sl->getPath().getType() == "pli")

      string += QString::fromStdWString(m_sl->getPalette()->getPaletteName()) +

                ".pli (palette)";

    else

      string += QString::fromStdWString(m_sl->getPalette()->getPaletteName()) +

                ".tpl";

  }

  return string;

}

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

//

// ScenePalette

//

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

ScenePalette::ScenePalette(ToonzScene *scene, TXshPaletteLevel *pl)

    : SceneResource(scene)

    , m_pl(pl)

    , m_oldPath(pl->getPath())

    , m_oldActualPath(scene->decodeFilePath(pl->getPath())) {}

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

void ScenePalette::save() {

  assert(m_oldPath != TFilePath());

  TFilePath fp = m_oldPath;

  SceneResource::updatePath(fp);

  TFilePath actualFp = m_scene->decodeFilePath(fp);

  try {

    TSystem::touchParentDir(actualFp);

    if (actualFp != m_oldActualPath &&

        TSystem::doesExistFileOrLevel(m_oldActualPath)) {

      TSystem::copyFile(actualFp, m_oldActualPath);

    }

    m_pl->save();  // actualFp non so perche' era cosi'

  } catch (...) {

    TLogger::error() << "Can't save " << actualFp;

  }

}

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

void ScenePalette::updatePath() {

  TFilePath fp = m_oldPath;

  SceneResource::updatePath(fp);

  if (fp != m_oldPath) m_pl->setPath(fp);

}

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

void ScenePalette::rollbackPath() { m_pl->setPath(m_oldPath); }

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

bool ScenePalette::isDirty() { return m_pl->getPalette()->getDirtyFlag(); }

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

QString ScenePalette::getResourceName() {

  return QString::fromStdString(m_pl->getPath().getLevelName());

}

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

//

// SceneSound

//

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

SceneSound::SceneSound(ToonzScene *scene, TXshSoundLevel *sl)

    : SceneResource(scene)

    , m_sl(sl)

    , m_oldPath(sl->getPath())

    , m_oldActualPath(scene->decodeFilePath(sl->getPath())) {}

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

void SceneSound::save() {

  assert(m_oldPath != TFilePath());

  TFilePath fp = m_oldPath;

  SceneResource::updatePath(fp);

  TFilePath actualFp = m_scene->decodeFilePath(fp);

  try {

    TSystem::touchParentDir(actualFp);

    if (!TSystem::doesExistFileOrLevel(m_oldActualPath)) {

      m_sl->save(actualFp);

    } else if (actualFp != m_oldActualPath) {

      TSystem::copyFile(actualFp, m_oldActualPath);

    }

  } catch (...) {

    TLogger::error() << "Can't save " << actualFp;

  }

}

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

void SceneSound::updatePath() {

  TFilePath fp = m_oldPath;

  SceneResource::updatePath(fp);

  if (fp != m_oldPath) m_sl->setPath(fp);

}

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

void SceneSound::rollbackPath() { m_sl->setPath(m_oldPath); }

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

//

// SceneResources

//

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

SceneResources::SceneResources(ToonzScene *scene, TXsheet *subXsheet)

    : m_scene(scene)

    , m_commitDone(false)

    , m_wasUntitled(scene->isUntitled())

    , m_subXsheet(subXsheet) {

  getResources();

}

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

SceneResources::~SceneResources() {

  if (!m_commitDone) rollbackPaths();

  clearPointerContainer(m_resources);

}

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

void SceneResources::getResources() {

  ToonzScene *scene = m_scene;

  std::vector<txshlevel *=""> levels;</txshlevel>

  scene->getLevelSet()->listLevels(levels);

  std::vector<txshlevel *="">::iterator it;</txshlevel>

  for (it = levels.begin(); it != levels.end(); ++it) {

    TXshSimpleLevel *sl = (*it)->getSimpleLevel();

    if (sl) m_resources.push_back(new SceneLevel(scene, sl));

    TXshPaletteLevel *pl = (*it)->getPaletteLevel();

    if (pl) m_resources.push_back(new ScenePalette(scene, pl));

    TXshSoundLevel *sdl = (*it)->getSoundLevel();

    if (sdl) m_resources.push_back(new SceneSound(scene, sdl));

  }

}

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

void SceneResources::save(const TFilePath newScenePath) {

  TFilePath oldScenePath = m_scene->getScenePath();

  m_scene->setScenePath(newScenePath);

  for (int i = 0; i < (int)m_resources.size(); i++) m_resources[i]->save();

  m_scene->setScenePath(oldScenePath);

}

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

void SceneResources::updatePaths() {

  for (int i = 0; i < (int)m_resources.size(); i++)

    m_resources[i]->updatePath();

}

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

void SceneResources::rollbackPaths() {

  for (int i = 0; i < (int)m_resources.size(); i++)

    m_resources[i]->rollbackPath();

}

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

void SceneResources::accept(ResourceProcessor *processor, bool autoCommit) {

  for (int i = 0; i < (int)m_resources.size() && !processor->aborted(); i++)

    m_resources[i]->accept(processor);

  if (autoCommit) commit();

}

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

// return the name list of dirty resources

void SceneResources::getDirtyResources(std::vector<qstring> &dirtyResources) {</qstring>

  for (int i = 0; i < (int)m_resources.size(); i++)

    if (m_resources[i]->isDirty()) {

      dirtyResources.push_back(m_resources[i]->getResourceName());

    }

}

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

//

// ResourceImporter

//

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

ResourceImporter::ResourceImporter(ToonzScene *scene, TProject *dstProject,

                                   ResourceImportStrategy &importStrategy)

    : m_scene(scene)

    , m_dstProject(dstProject)

    , m_dstScene(new ToonzScene())

    , m_importStrategy(importStrategy) {

  m_dstScene->setProject(dstProject);

  TFilePath newFp =

      dstProject->getScenesPath() +

      (scene->getScenePath() - scene->getProject()->getScenesPath());

  makeUnique(newFp);

  m_dstScene->setScenePath(newFp);

}

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

ResourceImporter::~ResourceImporter() { delete m_dstScene; }

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

bool ResourceImporter::makeUnique(TFilePath &path) {

  return makePathUnique(m_dstScene, path);

}

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

TFilePath ResourceImporter::getImportedScenePath() const {

  return m_dstScene->getScenePath();

}

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

TFilePath ResourceImporter::codePath(const TFilePath &oldPath,

                                     const TFilePath &newActualPath) {

  return oldPath.withName(newActualPath.getName());

}

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

std::string ResourceImporter::extractPsdSuffix(TFilePath &path) {

  if (path.getType() != "psd") return "";

  std::string name = path.getName();

  int i            = name.find("#");

  if (i == std::string::npos) return "";

  std::string suffix = name.substr(i);

  path               = path.withName(name.substr(0, i));

  return suffix;

}

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

TFilePath ResourceImporter::buildPsd(const TFilePath &basePath,

                                     const std::string &suffix) {

  return basePath.withName(basePath.getName() + suffix);

}

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

void ResourceImporter::process(TXshSimpleLevel *sl) {

  if (sl->getPath().isAbsolute()) return;

  TFilePath newPath;

  TFilePath slPath   = sl->getPath();

  std::string suffix = extractPsdSuffix(slPath);

  TFilePath imgRefPath;

  if (sl->getPalette()) imgRefPath = sl->getPalette()->getRefImgPath();

  newPath = m_importStrategy.process(m_dstScene, m_scene, slPath);

  if (imgRefPath != TFilePath() &&

      !m_dstScene->isExternPath(m_dstScene->decodeFilePath(imgRefPath)))

    m_importStrategy.process(m_dstScene, m_scene, imgRefPath);

  if (suffix != "") newPath = buildPsd(newPath, suffix);

  sl->setPath(newPath);

  if (sl->getScannedPath() != TFilePath()) {

    newPath =

        m_importStrategy.process(m_dstScene, m_scene, sl->getScannedPath());

    sl->setScannedPath(newPath);

  }

  sl->setDirtyFlag(false);

}

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

void ResourceImporter::process(TXshPaletteLevel *pl) {

  if (pl->getPath().isAbsolute()) return;

  TFilePath newPath;

  newPath = m_importStrategy.process(m_dstScene, m_scene, pl->getPath());

  pl->setPath(newPath);

}

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

void ResourceImporter::process(TXshSoundLevel *sl) {

  if (sl->getPath().isAbsolute()) return;

  TFilePath newPath;

  newPath = m_importStrategy.process(m_dstScene, m_scene, sl->getPath());

  sl->setPath(newPath);

}

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

//

// ResourceCollector

//

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

ResourceCollector::ResourceCollector(ToonzScene *scene)

    : m_scene(scene), m_count(0) {}

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

ResourceCollector::~ResourceCollector() {}

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

bool ResourceCollector::makeUnique(TFilePath &path) {

  return makePathUnique(m_scene, path);

}

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

void ResourceCollector::process(TXshSimpleLevel *sl) {

  TFilePath path     = sl->getPath();

  std::string suffix = ResourceImporter::extractPsdSuffix(path);

  std::map<tfilepath, tfilepath="">::iterator it = m_collectedFiles.find(path);</tfilepath,>

  if (it != m_collectedFiles.end()) {

    TFilePath destPath         = it->second;

    if (suffix != "") destPath = ResourceImporter::buildPsd(destPath, suffix);

    sl->setPath(destPath);

  } else {

    TFilePath collectedPath = path;

    if (getCollectedPath(m_scene, collectedPath)) {

      TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);

      if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path) &&

          !TSystem::doesExistFileOrLevel(actualCollectedPath)) {

        try {

          TSystem::touchParentDir(actualCollectedPath);

          TXshSimpleLevel::copyFiles(actualCollectedPath, path);

        } catch (...) {

        }

      }

      ++m_count;

      TFilePath destPath         = collectedPath;

      if (suffix != "") destPath = ResourceImporter::buildPsd(destPath, suffix);

      sl->setPath(destPath);

      m_collectedFiles[path] = collectedPath;

    }

  }

  if (sl->getScannedPath() != TFilePath()) {

    path                    = sl->getScannedPath();

    TFilePath collectedPath = path;

    if (getCollectedPath(m_scene, collectedPath)) {

      TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);

      if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path)) {

        try {

          TSystem::touchParentDir(actualCollectedPath);

          TXshSimpleLevel::copyFiles(actualCollectedPath, path);

        } catch (...) {

        }

      }

      sl->setScannedPath(collectedPath);

      m_count++;

    }

  }

  sl->setDirtyFlag(false);

}

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

void ResourceCollector::process(TXshSoundLevel *sl) {

  TFilePath path          = sl->getPath();

  TFilePath collectedPath = path;

  if (!getCollectedPath(m_scene, collectedPath)) return;

  TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);

  if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path)) {

    try {

      TSystem::touchParentDir(actualCollectedPath);

      TXshSimpleLevel::copyFiles(actualCollectedPath, path);

    } catch (...) {

    }

  }

  sl->setPath(collectedPath);

  m_count++;

}

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

void ResourceCollector::process(TXshPaletteLevel *pl) {

  TFilePath path          = pl->getPath();

  TFilePath collectedPath = path;

  if (!getCollectedPath(m_scene, collectedPath)) return;

  TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);

  if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path)) {

    try {

      TSystem::touchParentDir(actualCollectedPath);

      TXshSimpleLevel::copyFiles(actualCollectedPath, path);

    } catch (...) {

    }

  }

  pl->setPath(collectedPath);

  m_count++;

}