// TnzCore includes

#include "tconvert.h"

#include "tstream.h"

// TnzLib includes

#include "toonz/txshsimplelevel.h"

#include "toonz/toonzscene.h"

#include "toonz/levelset.h"

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

namespace

{

const TFilePath defaultRootFolder("Cast");

const TFilePath defaultSoundRootFolder("Audio");

}

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

// TLevelSet

TLevelSet::TLevelSet()

	: m_defaultFolder(defaultRootFolder)

{

	m_folders.push_back(defaultRootFolder);

	m_folders.push_back(defaultSoundRootFolder);

}

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

TLevelSet::~TLevelSet()

{

	clear();

}

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

void TLevelSet::clear()

{

	for (std::vector<txshlevel *="">::iterator it = m_levels.begin();</txshlevel>

		 it != m_levels.end(); ++it) {

		TXshLevel *level = *it;

		if (level->getSimpleLevel())

			level->getSimpleLevel()->clearFrames();

		(*it)->release();

	}

	m_levelTable.clear();

	m_levels.clear();

	m_folderTable.clear();

	m_folders.clear();

	m_folders.push_back(defaultRootFolder);

	m_folders.push_back(defaultSoundRootFolder);

	m_defaultFolder = defaultRootFolder;

}

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

void TLevelSet::removeLevel(TXshLevel *level, bool deleteIt)

{

	//if(level->getSimpleLevel())

	//  level->getSimpleLevel()->clearFrames();

	m_levels.erase(

		std::remove(m_levels.begin(), m_levels.end(), level),

		m_levels.end());

	m_levelTable.erase(level->getName());

	if (deleteIt)

		level->release();

	m_folderTable.erase(level);

}

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

bool TLevelSet::renameLevel(TXshLevel *level, const std::wstring &newName)

{

	if (level->getName() == newName)

		return true;

	if (m_levelTable.count(newName) > 0)

		return false;

	m_levelTable.erase(level->getName());

	level->setName(newName);

	m_levelTable[newName] = level;

	return true;

}

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

int TLevelSet::getLevelCount() const

{

	return m_levels.size();

}

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

TXshLevel *TLevelSet::getLevel(int index) const

{

	assert(0 <= index && index < getLevelCount());

	return m_levels[index];

}

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

TXshLevel *TLevelSet::getLevel(const std::wstring &levelName) const

{

	std::map<std::wstring, *="" txshlevel="">::const_iterator it;</std::wstring,>

	it = m_levelTable.find(levelName);

	if (it == m_levelTable.end())

		return 0;

	else

		return it->second;

}

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

TXshLevel *TLevelSet::getLevel(const ToonzScene &scene, const TFilePath &levelPath) const

{

	const TFilePath &decodedPath = scene.decodeFilePath(levelPath);

	int l, lCount = getLevelCount();

	for (l = 0; l != lCount; ++l) {

		TXshLevel *level = getLevel(l);

		if (decodedPath == scene.decodeFilePath(level->getPath()))

			return level;

	}

	return 0;

}

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

bool TLevelSet::hasLevel(const std::wstring &levelName) const

{

	std::vector<txshlevel *="">::const_iterator it = m_levels.begin();</txshlevel>

	for (it; it != m_levels.end(); it++) {

		TXshLevel *level = *it;

		if (levelName == level->getName())

			return true;

	}

	return false;

}

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

bool TLevelSet::hasLevel(const ToonzScene &scene, const TFilePath &levelPath) const

{

	return getLevel(scene, levelPath);

}

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

void TLevelSet::listLevels(std::vector<txshlevel *=""> &levels) const</txshlevel>

{

	levels = m_levels;

}

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

bool TLevelSet::insertLevel(TXshLevel *xl)

{

	std::map<std::wstring, *="" txshlevel="">::const_iterator it;</std::wstring,>

	it = m_levelTable.find(xl->getName());

	if (it != m_levelTable.end() && it->second == xl)

		return it->second == xl;

	else {

		xl->addRef();

		m_levelTable[xl->getName()] = xl;

		m_levels.push_back(xl);

		TFilePath folder = (xl->getSoundLevel()) ? defaultSoundRootFolder : m_defaultFolder;

		m_folderTable[xl] = folder;

		assert(std::find(m_folders.begin(), m_folders.end(), folder) != m_folders.end());

		return true;

	}

}

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

void TLevelSet::setDefaultFolder(TFilePath folder)

{

	assert(std::find(m_folders.begin(), m_folders.end(), folder) != m_folders.end());

	m_defaultFolder = folder;

}

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

TFilePath TLevelSet::getFolder(TXshLevel *xl) const

{

	std::map<txshlevel *,="" tfilepath="">::const_iterator it;</txshlevel>

	it = m_folderTable.find(xl);

	assert(it != m_folderTable.end());

	return it->second;

}

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

TFilePath TLevelSet::renameFolder(const TFilePath &folder, const std::wstring &newName)

{

	// Impedisco la creazione di folder con nome "" che creano problemi

	// (praticamente Ecome se avessero infinite sottocartelle)

	if (newName == L"")

		return folder;

	TFilePath folder2 = folder.withName(newName);

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

		if (folder == m_folders[i])

			m_folders[i] = folder2;

		else if (folder.isAncestorOf(m_folders[i]))

			m_folders[i] = folder2 + (m_folders[i] - folder);

	}

	if (m_defaultFolder == folder)

		m_defaultFolder = folder2;

	std::map<txshlevel *,="" tfilepath="">::iterator it;</txshlevel>

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

		if (folder == it->second)

			it->second = folder2;

		else if (folder.isAncestorOf(it->second))

			it->second = folder2 + (it->second - folder);

	}

	return folder2;

}

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

TFilePath TLevelSet::createFolder(const TFilePath &parentFolder, const std::wstring &newName)

{

	TFilePath child = parentFolder + newName;

	if (std::find(m_folders.begin(), m_folders.end(), child) == m_folders.end())

		m_folders.push_back(child);

	return child;

}

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

void TLevelSet::removeFolder(const TFilePath &folder)

{

	if (folder == m_defaultFolder)

		return;

	std::vector<tfilepath> folders;</tfilepath>

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

		if (!folder.isAncestorOf(m_folders[i]))

			folders.push_back(m_folders[i]);

	folders.swap(m_folders);

	std::map<txshlevel *,="" tfilepath="">::iterator it;</txshlevel>

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

		if (folder.isAncestorOf(it->second))

			it->second = m_defaultFolder;

	}

}

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

void TLevelSet::listLevels(std::vector<txshlevel *=""> &levels, const TFilePath &folder) const</txshlevel>

{

	std::map<txshlevel *,="" tfilepath="">::const_iterator it;</txshlevel>

	for (it = m_folderTable.begin(); it != m_folderTable.end(); ++it)

		if (folder == it->second)

			levels.push_back(it->first);

}

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

void TLevelSet::listFolders(std::vector<tfilepath> &folders, const TFilePath &folder) const</tfilepath>

{

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

		if (m_folders[i].getParentDir() == folder)

			folders.push_back(m_folders[i]);

}

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

void TLevelSet::moveLevelToFolder(const TFilePath &fp, TXshLevel *level)

{

	TFilePath folder(fp);

	if (folder == TFilePath())

		folder = m_defaultFolder;

	if (std::find(m_folders.begin(), m_folders.end(), folder) == m_folders.end()) {

		assert(0);

		return;

	}

	std::map<txshlevel *,="" tfilepath="">::iterator it;</txshlevel>

	it = m_folderTable.find(level);

	assert(it != m_folderTable.end());

	if (it == m_folderTable.end())

		return;

	it->second = folder;

}

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

void TLevelSet::saveFolder(TOStream &os, TFilePath folder)

{

	std::map<std::string, std::string=""> attr;</std::string,>

	attr["name"] = folder.getName();

	if (folder == getDefaultFolder())

		attr["type"] = "default";

	os.openChild("folder", attr);

	std::vector<tfilepath> folders;</tfilepath>

	listFolders(folders, folder);

	if (!folders.empty()) {

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

			saveFolder(os, folders[i]);

	}

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

	listLevels(levels, folder);

	if (!levels.empty()) {

		os.openChild("levels");

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

			if (m_saveSet.empty() || m_saveSet.count(levels[i]) > 0)

				os << levels[i];

		os.closeChild();

	}

	os.closeChild();

}

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

void TLevelSet::loadFolder(TIStream &is, TFilePath folder)

{

	std::string s;

	is.getTagParam("type", s);

	if (s == "default")

		setDefaultFolder(folder);

	while (!is.eos()) {

		std::string tagName;

		is.matchTag(tagName);

		if (tagName == "levels") {

			while (!is.eos()) {

				TPersist *p = 0;

				is >> p;

				TXshLevel *xshLevel = dynamic_cast<txshlevel *="">(p);</txshlevel>

				if (xshLevel && !xshLevel->getChildLevel())

					moveLevelToFolder(folder, xshLevel);

			}

		} else if (tagName == "folder") {

			is.getTagParam("name", s);

			TFilePath child = createFolder(folder, toWideString(s));

			loadFolder(is, child);

		} else

			throw TException("expected <levels> or <folder>");</folder></levels>

		is.closeChild();

	}

}

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

void TLevelSet::loadData(TIStream &is)

{

	int folderCount = 1;

	while (!is.eos()) {

		std::string tagName;

		if (is.matchTag(tagName)) {

			if (tagName == "levels") {

				while (!is.eos()) {

					TPersist *p = 0;

					is >> p;

					TXshLevel *xshLevel = dynamic_cast<txshlevel *="">(p);</txshlevel>

					if (xshLevel) {

						insertLevel(xshLevel);

					}

				}

			} else if (tagName == "folder") {

				std::string name = toString(defaultRootFolder.getWideString());

				is.getTagParam("name", name);

				TFilePath folder(name);

				if (folderCount == 1)

					m_defaultFolder = m_folders[0] = folder;

				else if (name != defaultSoundRootFolder.getName())

					m_folders.push_back(folder);

				folderCount++;

				loadFolder(is, folder);

			} else

				throw TException("expected <levels> or <folder>");</folder></levels>

			is.closeChild();

		} else

			throw TException("expected tag");

	}

}

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

void TLevelSet::saveData(TOStream &os)

{

	os.openChild("levels");

	int i;

	for (i = 0; i < getLevelCount(); i++) {

		TXshLevel *level = getLevel(i);

		if (m_saveSet.empty() || m_saveSet.count(level) > 0)

			os << level;

	}

	os.closeChild();

	std::vector<tfilepath> folders;</tfilepath>

	listFolders(folders, TFilePath());

	assert(!folders.empty());

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

		saveFolder(os, folders[i]);

}