1 files changed, 118 insertions, 88 deletions

diff --git a/api/logic/InstanceImportTask.cpp b/api/logic/InstanceImportTask.cpp
index f1b3d5aa..2b481300 100644
--- a/api/logic/InstanceImportTask.cpp
+++ b/api/logic/InstanceImportTask.cpp
@@ -1,5 +1,3 @@
-#include "minecraft/onesix/OneSixInstance.h"
-
 #include "InstanceImportTask.h"
 #include "BaseInstance.h"
 #include "BaseInstanceProvider.h"
@@ -12,16 +10,18 @@
 #include <QtConcurrentRun>
 
 // FIXME: this does not belong here, it's Minecraft/Flame specific
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/ComponentList.h"
 #include "minecraft/flame/FileResolvingTask.h"
 #include "minecraft/flame/PackManifest.h"
 #include "Json.h"
 
-InstanceImportTask::InstanceImportTask(SettingsObjectPtr settings, const QUrl sourceUrl, BaseInstanceProvider * target,
+InstanceImportTask::InstanceImportTask(SettingsObjectPtr settings, const QUrl sourceUrl, const QString & stagingPath,
 	const QString &instName, const QString &instIcon, const QString &instGroup)
 {
 	m_globalSettings = settings;
 	m_sourceUrl = sourceUrl;
-	m_target = target;
+	m_stagingPath = stagingPath;
 	m_instName = instName;
 	m_instIcon = instIcon;
 	m_instGroup = instGroup;
@@ -34,7 +34,7 @@ void InstanceImportTask::executeTask()
 	if (m_sourceUrl.isLocalFile())
 	{
 		m_archivePath = m_sourceUrl.toLocalFile();
-		extractAndTweak();
+		processZipPack();
 	}
 	else
 	{
@@ -57,7 +57,7 @@ void InstanceImportTask::executeTask()
 
 void InstanceImportTask::downloadSucceeded()
 {
-	extractAndTweak();
+	processZipPack();
 	m_filesNetJob.reset();
 }
 
@@ -72,34 +72,47 @@ void InstanceImportTask::downloadProgressChanged(qint64 current, qint64 total)
 	setProgress(current / 2, total);
 }
 
-static QFileInfo findRecursive(const QString &dir, const QString &name)
-{
-	for (const auto info : QDir(dir).entryInfoList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files, QDir::DirsLast))
-	{
-		if (info.isFile() && info.fileName() == name)
-		{
-			return info;
-		}
-		else if (info.isDir())
-		{
-			const QFileInfo res = findRecursive(info.absoluteFilePath(), name);
-			if (res.isFile() && res.exists())
-			{
-				return res;
-			}
-		}
-	}
-	return QFileInfo();
-}
-
-void InstanceImportTask::extractAndTweak()
+void InstanceImportTask::processZipPack()
 {
 	setStatus(tr("Extracting modpack"));
-	m_stagingPath = m_target->getStagedInstancePath();
 	QDir extractDir(m_stagingPath);
 	qDebug() << "Attempting to create instance from" << m_archivePath;
 
-	m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, m_archivePath, extractDir.absolutePath());
+	// open the zip and find relevant files in it
+	m_packZip.reset(new QuaZip(m_archivePath));
+	if (!m_packZip->open(QuaZip::mdUnzip))
+	{
+		emitFailed(tr("Unable to open supplied modpack zip file."));
+		return;
+	}
+
+	QStringList blacklist = {"instance.cfg", "manifest.json"};
+	QString mmcFound = MMCZip::findFolderOfFileInZip(m_packZip.get(), "instance.cfg");
+	QString flameFound = MMCZip::findFolderOfFileInZip(m_packZip.get(), "manifest.json");
+	QString root;
+	if(!mmcFound.isNull())
+	{
+		// process as MultiMC instance/pack
+		qDebug() << "MultiMC:" << mmcFound;
+		root = mmcFound;
+		m_modpackType = ModpackType::MultiMC;
+	}
+	else if(!flameFound.isNull())
+	{
+		// process as Flame pack
+		qDebug() << "Flame:" << flameFound;
+		root = flameFound;
+		m_modpackType = ModpackType::Flame;
+	}
+
+	if(m_modpackType == ModpackType::Unknown)
+	{
+		emitFailed(tr("Archive does not contain a recognized modpack type."));
+		return;
+	}
+
+	// make sure we extract just the pack
+	m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractSubDir, m_packZip.get(), root, extractDir.absolutePath());
 	connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &InstanceImportTask::extractFinished);
 	connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &InstanceImportTask::extractAborted);
 	m_extractFutureWatcher.setFuture(m_extractFuture);
@@ -107,9 +120,9 @@ void InstanceImportTask::extractAndTweak()
 
 void InstanceImportTask::extractFinished()
 {
+	m_packZip.reset();
 	if (m_extractFuture.result().isEmpty())
 	{
-		m_target->destroyStagingPath(m_stagingPath);
 		emitFailed(tr("Failed to extract modpack"));
 		return;
 	}
@@ -137,7 +150,7 @@ void InstanceImportTask::extractFinished()
 		{
 			if(!QFile::setPermissions(filepath, permissions))
 			{
-				qWarning() << "Could not fix" << filepath;
+				logWarning(tr("Could not fix permissions for %1").arg(filepath));
 			}
 			else
 			{
@@ -146,34 +159,27 @@ void InstanceImportTask::extractFinished()
 		}
 	}
 
-	const QFileInfo instanceCfgFile = findRecursive(extractDir.absolutePath(), "instance.cfg");
-	const QFileInfo flameJson = findRecursive(extractDir.absolutePath(), "manifest.json");
-	if (instanceCfgFile.isFile())
-	{
-		qDebug() << "Pack appears to be exported from MultiMC.";
-		processMultiMC(instanceCfgFile);
-	}
-	else if (flameJson.isFile())
+	switch(m_modpackType)
 	{
-		qDebug() << "Pack appears to be from 'Flame'.";
-		processFlame(flameJson);
-	}
-	else
-	{
-		qCritical() << "Archive does not contain a recognized modpack type.";
-		m_target->destroyStagingPath(m_stagingPath);
-		emitFailed(tr("Archive does not contain a recognized modpack type."));
+		case ModpackType::Flame:
+			processFlame();
+			return;
+		case ModpackType::MultiMC:
+			processMultiMC();
+			return;
+		case ModpackType::Unknown:
+			emitFailed(tr("Archive does not contain a recognized modpack type."));
+			return;
 	}
 }
 
 void InstanceImportTask::extractAborted()
 {
-	m_target->destroyStagingPath(m_stagingPath);
 	emitFailed(tr("Instance import has been aborted."));
 	return;
 }
 
-void InstanceImportTask::processFlame(const QFileInfo & manifest)
+void InstanceImportTask::processFlame()
 {
 	const static QMap<QString,QString> forgemap = {
 		{"1.2.5", "3.4.9.171"},
@@ -184,24 +190,30 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 	Flame::Manifest pack;
 	try
 	{
-		Flame::loadManifest(pack, manifest.absoluteFilePath());
+		QString configPath = FS::PathCombine(m_stagingPath, "manifest.json");
+		Flame::loadManifest(pack, configPath);
+		QFile::remove(configPath);
 	}
 	catch (JSONValidationError & e)
 	{
-		m_target->destroyStagingPath(m_stagingPath);
 		emitFailed(tr("Could not understand pack manifest:\n") + e.cause());
 		return;
 	}
-	m_packRoot = manifest.absolutePath();
 	if(!pack.overrides.isEmpty())
 	{
-		QString overridePath = FS::PathCombine(m_packRoot, pack.overrides);
-		QString mcPath = FS::PathCombine(m_packRoot, "minecraft");
-		if (!QFile::rename(overridePath, mcPath))
+		QString overridePath = FS::PathCombine(m_stagingPath, pack.overrides);
+		if (QFile::exists(overridePath))
 		{
-			m_target->destroyStagingPath(m_stagingPath);
-			emitFailed(tr("Could not rename the overrides folder:\n") + pack.overrides);
-			return;
+			QString mcPath = FS::PathCombine(m_stagingPath, "minecraft");
+			if (!QFile::rename(overridePath, mcPath))
+			{
+				emitFailed(tr("Could not rename the overrides folder:\n") + pack.overrides);
+				return;
+			}
+		}
+		else
+		{
+			logWarning(tr("The specified overrides folder (%1) is missing. Maybe the modpack was already used before?").arg(pack.overrides));
 		}
 	}
 
@@ -215,22 +227,24 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 			forgeVersion = id;
 			continue;
 		}
-		qWarning() << "Unknown mod loader in manifest:" << id;
+		logWarning(tr("Unknown mod loader in manifest: %1").arg(id));
 	}
 
-	QString configPath = FS::PathCombine(m_packRoot, "instance.cfg");
+	QString configPath = FS::PathCombine(m_stagingPath, "instance.cfg");
 	auto instanceSettings = std::make_shared<INISettingsObject>(configPath);
 	instanceSettings->registerSetting("InstanceType", "Legacy");
 	instanceSettings->set("InstanceType", "OneSix");
-	OneSixInstance instance(m_globalSettings, instanceSettings, m_packRoot);
+	MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
 	auto mcVersion = pack.minecraft.version;
 	// Hack to correct some 'special sauce'...
 	if(mcVersion.endsWith('.'))
 	{
 		mcVersion.remove(QRegExp("[.]+$"));
-		qWarning() << "Mysterious trailing dots removed from Minecraft version while importing pack.";
+		logWarning(tr("Mysterious trailing dots removed from Minecraft version while importing pack."));
 	}
-	instance.setComponentVersion("net.minecraft", mcVersion);
+	auto components = instance.getComponentList();
+	components->buildingFromScratch();
+	components->setComponentVersion("net.minecraft", mcVersion, true);
 	if(!forgeVersion.isEmpty())
 	{
 		// FIXME: dirty, nasty, hack. Proper solution requires dependency resolution and knowledge of the metadata.
@@ -242,10 +256,10 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 			}
 			else
 			{
-				qWarning() << "Could not map recommended forge version for" << mcVersion;
+				logWarning(tr("Could not map recommended forge version for Minecraft %1").arg(mcVersion));
 			}
 		}
-		instance.setComponentVersion("net.minecraftforge", forgeVersion);
+		components->setComponentVersion("net.minecraftforge", forgeVersion);
 	}
 	if (m_instIcon != "default")
 	{
@@ -268,7 +282,7 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 		}
 	}
 	instance.init();
-	QString jarmodsPath = FS::PathCombine(m_packRoot, "minecraft", "jarmods");
+	QString jarmodsPath = FS::PathCombine(m_stagingPath, "minecraft", "jarmods");
 	QFileInfo jarmodsInfo(jarmodsPath);
 	if(jarmodsInfo.isDir())
 	{
@@ -281,7 +295,7 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 			qDebug() << info.fileName();
 			jarMods.push_back(info.absoluteFilePath());
 		}
-		auto profile = instance.getMinecraftProfile();
+		auto profile = instance.getComponentList();
 		profile->installJarMods(jarMods);
 		// nuke the original files
 		FS::deletePath(jarmodsPath);
@@ -294,26 +308,49 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 		m_filesNetJob.reset(new NetJob(tr("Mod download")));
 		for(auto result: results.files)
 		{
-			auto path = FS::PathCombine(m_packRoot, "minecraft/mods", result.fileName);
-			auto dl = Net::Download::makeFile(result.url,path);
-			m_filesNetJob->addNetAction(dl);
+			QString filename = result.fileName;
+			if(!result.required)
+			{
+				filename += ".disabled";
+			}
+
+			auto relpath = FS::PathCombine("minecraft", result.targetFolder, filename);
+			auto path = FS::PathCombine(m_stagingPath , relpath);
+
+			switch(result.type)
+			{
+				case Flame::File::Type::Folder:
+				{
+					logWarning(tr("This 'Folder' may need extracting: %1").arg(relpath));
+					// fall-through intentional, we treat these as plain old mods and dump them wherever.
+				}
+				case Flame::File::Type::SingleFile:
+				case Flame::File::Type::Mod:
+				{
+					qDebug() << "Will download" << result.url << "to" << path;
+					auto dl = Net::Download::makeFile(result.url, path);
+					m_filesNetJob->addNetAction(dl);
+					break;
+				}
+				case Flame::File::Type::Modpack:
+					logWarning(tr("Nesting modpacks in modpacks is not implemented, nothing was downloaded: %1").arg(relpath));
+					break;
+				case Flame::File::Type::Cmod2:
+				case Flame::File::Type::Ctoc:
+				case Flame::File::Type::Unknown:
+					logWarning(tr("Unrecognized/unhandled PackageType for: %1").arg(relpath));
+					break;
+			}
 		}
 		m_modIdResolver.reset();
 		connect(m_filesNetJob.get(), &NetJob::succeeded, this, [&]()
 		{
 			m_filesNetJob.reset();
-			if (!m_target->commitStagedInstance(m_stagingPath, m_packRoot, m_instName, m_instGroup))
-			{
-				m_target->destroyStagingPath(m_stagingPath);
-				emitFailed(tr("Unable to commit instance"));
-				return;
-			}
 			emitSucceeded();
 		}
 		);
 		connect(m_filesNetJob.get(), &NetJob::failed, [&](QString reason)
 		{
-			m_target->destroyStagingPath(m_stagingPath);
 			m_filesNetJob.reset();
 			emitFailed(reason);
 		});
@@ -327,7 +364,6 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 	);
 	connect(m_modIdResolver.get(), &Flame::FileResolvingTask::failed, [&](QString reason)
 	{
-		m_target->destroyStagingPath(m_stagingPath);
 		m_modIdResolver.reset();
 		emitFailed(tr("Unable to resolve mod IDs:\n") + reason);
 	});
@@ -342,14 +378,14 @@ void InstanceImportTask::processFlame(const QFileInfo & manifest)
 	m_modIdResolver->start();
 }
 
-void InstanceImportTask::processMultiMC(const QFileInfo & config)
+void InstanceImportTask::processMultiMC()
 {
 	// FIXME: copy from FolderInstanceProvider!!! FIX IT!!!
-	auto instanceSettings = std::make_shared<INISettingsObject>(config.absoluteFilePath());
+	QString configPath = FS::PathCombine(m_stagingPath, "instance.cfg");
+	auto instanceSettings = std::make_shared<INISettingsObject>(configPath);
 	instanceSettings->registerSetting("InstanceType", "Legacy");
 
-	QString actualDir = config.absolutePath();
-	NullInstance instance(m_globalSettings, instanceSettings, actualDir);
+	NullInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
 
 	// reset time played on import... because packs.
 	instance.resetTimePlayed();
@@ -377,11 +413,5 @@ void InstanceImportTask::processMultiMC(const QFileInfo & config)
 			iconList->installIcons({importIconPath});
 		}
 	}
-	if (!m_target->commitStagedInstance(m_stagingPath, actualDir, m_instName, m_instGroup))
-	{
-		m_target->destroyStagingPath(m_stagingPath);
-		emitFailed(tr("Unable to commit instance"));
-		return;
-	}
 	emitSucceeded();
 }