path: root/api/logic/InstanceList.cpp

/* Copyright 2013-2018 MultiMC Contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <QDir>
#include <QSet>
#include <QFile>
#include <QThread>
#include <QTextStream>
#include <QXmlStreamReader>
#include <QDebug>

#include "InstanceList.h"
#include "BaseInstance.h"

#include "FolderInstanceProvider.h"

InstanceList::InstanceList(QObject *parent)
	: QAbstractListModel(parent)
{
	resumeWatch();
}

InstanceList::~InstanceList()
{
}

int InstanceList::rowCount(const QModelIndex &parent) const
{
	Q_UNUSED(parent);
	return m_instances.count();
}

QModelIndex InstanceList::index(int row, int column, const QModelIndex &parent) const
{
	Q_UNUSED(parent);
	if (row < 0 || row >= m_instances.size())
		return QModelIndex();
	return createIndex(row, column, (void *)m_instances.at(row).get());
}

QVariant InstanceList::data(const QModelIndex &index, int role) const
{
	if (!index.isValid())
	{
		return QVariant();
	}
	BaseInstance *pdata = static_cast<BaseInstance *>(index.internalPointer());
	switch (role)
	{
	case InstancePointerRole:
	{
		QVariant v = qVariantFromValue((void *)pdata);
		return v;
	}
	case InstanceIDRole:
    {
        return pdata->id();
    }
	case Qt::DisplayRole:
	{
		return pdata->name();
	}
	case Qt::ToolTipRole:
	{
		return pdata->instanceRoot();
	}
	case Qt::DecorationRole:
	{
		return pdata->iconKey();
	}
	// HACK: see GroupView.h in gui!
	case GroupRole:
	{
		return pdata->group();
	}
	default:
		break;
	}
	return QVariant();
}

Qt::ItemFlags InstanceList::flags(const QModelIndex &index) const
{
	Qt::ItemFlags f;
	if (index.isValid())
	{
		f |= (Qt::ItemIsEnabled | Qt::ItemIsSelectable);
	}
	return f;
}

QStringList InstanceList::getGroups()
{
	return m_groups.toList();
}

void InstanceList::deleteGroup(const QString& name)
{
	for(auto & instance: m_instances)
	{
		auto instGroupName = instance->group();
		if(instGroupName == name)
		{
			instance->setGroupPost(QString());
		}
	}
}

static QMap<InstanceId, InstanceLocator> getIdMapping(const QList<InstancePtr> &list)
{
	QMap<InstanceId, InstanceLocator> out;
	int i = 0;
	for(auto & item: list)
	{
		auto id = item->id();
		if(out.contains(id))
		{
			qWarning() << "Duplicate ID" << id << "in instance list";
		}
		out[id] = std::make_pair(item, i);
		i++;
	}
	return out;
}

InstanceList::InstListError InstanceList::loadList(bool complete)
{
	auto existingIds = getIdMapping(m_instances);

	QList<InstancePtr> newList;

	auto processIds = [&](BaseInstanceProvider * provider, QList<InstanceId> ids)
	{
		for(auto & id: ids)
		{
			if(existingIds.contains(id))
			{
				auto instPair = existingIds[id];
				/*
				auto & instPtr = instPair.first;
				auto & instIdx = instPair.second;
				*/
				existingIds.remove(id);
				qDebug() << "Should keep and soft-reload" << id;
			}
			else
			{
				InstancePtr instPtr = provider->loadInstance(id);
				if(instPtr)
				{
					newList.append(instPtr);
				}
			}
		}
	};
	if(complete)
	{
		for(auto & item: m_providers)
		{
			processIds(item.get(), item->discoverInstances());
		}
	}
	else
	{
		for (auto & item: m_updatedProviders)
		{
			processIds(item, item->discoverInstances());
		}
	}

	// TODO: looks like a general algorithm with a few specifics inserted. Do something about it.
	if(!existingIds.isEmpty())
	{
		// get the list of removed instances and sort it by their original index, from last to first
		auto deadList = existingIds.values();
		auto orderSortPredicate = [](const InstanceLocator & a, const InstanceLocator & b) -> bool
		{
			return a.second > b.second;
		};
		std::sort(deadList.begin(), deadList.end(), orderSortPredicate);
		// remove the contiguous ranges of rows
		int front_bookmark = -1;
		int back_bookmark = -1;
		int currentItem = -1;
		auto removeNow = [&]()
		{
			beginRemoveRows(QModelIndex(), front_bookmark, back_bookmark);
			m_instances.erase(m_instances.begin() + front_bookmark, m_instances.begin() + back_bookmark + 1);
			endRemoveRows();
			front_bookmark = -1;
			back_bookmark = currentItem;
		};
		for(auto & removedItem: deadList)
		{
			auto instPtr = removedItem.first;
			if(!complete && !m_updatedProviders.contains(instPtr->provider()))
			{
				continue;
			}
			instPtr->invalidate();
			currentItem = removedItem.second;
			if(back_bookmark == -1)
			{
				// no bookmark yet
				back_bookmark = currentItem;
			}
			else if(currentItem == front_bookmark - 1)
			{
				// part of contiguous sequence, continue
			}
			else
			{
				// seam between previous and current item
				removeNow();
			}
			front_bookmark = currentItem;
		}
		if(back_bookmark != -1)
		{
			removeNow();
		}
	}
	if(newList.size())
	{
		add(newList);
	}
	m_updatedProviders.clear();
	return NoError;
}

void InstanceList::saveNow()
{
	for(auto & item: m_instances)
	{
		item->saveNow();
	}
}

void InstanceList::add(const QList<InstancePtr> &t)
{
	beginInsertRows(QModelIndex(), m_instances.count(), m_instances.count() + t.size() - 1);
	m_instances.append(t);
	for(auto & ptr : t)
	{
		connect(ptr.get(), &BaseInstance::propertiesChanged, this, &InstanceList::propertiesChanged);
	}
	endInsertRows();
}

void InstanceList::resumeWatch()
{
	if(m_watchLevel > 0)
	{
		qWarning() << "Bad suspend level resume in instance list";
		return;
	}
	m_watchLevel++;
	if(m_watchLevel > 0 && !m_updatedProviders.isEmpty())
	{
		loadList();
	}
}

void InstanceList::suspendWatch()
{
	m_watchLevel --;
}

void InstanceList::providerUpdated()
{
	auto provider = dynamic_cast<BaseInstanceProvider *>(QObject::sender());
	if(!provider)
	{
		qWarning() << "InstanceList::providerUpdated triggered by a non-provider";
		return;
	}
	m_updatedProviders.insert(provider);
	if(m_watchLevel == 1)
	{
		loadList();
	}
}

void InstanceList::groupsPublished(QSet<QString> newGroups)
{
	m_groups.unite(newGroups);
}

void InstanceList::addInstanceProvider(BaseInstanceProvider* provider)
{
	connect(provider, &BaseInstanceProvider::instancesChanged, this, &InstanceList::providerUpdated);
	connect(provider, &BaseInstanceProvider::groupsChanged, this, &InstanceList::groupsPublished);
	m_providers.append(provider);
}

InstancePtr InstanceList::getInstanceById(QString instId) const
{
	if(instId.isEmpty())
		return InstancePtr();
	for(auto & inst: m_instances)
	{
		if (inst->id() == instId)
		{
			return inst;
		}
	}
	return InstancePtr();
}

QModelIndex InstanceList::getInstanceIndexById(const QString &id) const
{
	return index(getInstIndex(getInstanceById(id).get()));
}

int InstanceList::getInstIndex(BaseInstance *inst) const
{
	int count = m_instances.count();
	for (int i = 0; i < count; i++)
	{
		if (inst == m_instances[i].get())
		{
			return i;
		}
	}
	return -1;
}

void InstanceList::propertiesChanged(BaseInstance *inst)
{
	int i = getInstIndex(inst);
	if (i != -1)
	{
		emit dataChanged(index(i), index(i));
	}
}