PrismLauncher/launcher/minecraft/mod/Mod.cpp

// SPDX-License-Identifier: GPL-3.0-only
/*
*  PolyMC - Minecraft Launcher
*  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
*  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
*
*  This program is free software: you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation, version 3.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program.  If not, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
*      Copyright 2013-2021 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 "Mod.h"

#include <QDebug>
#include <QDir>
#include <QString>

#include "MetadataHandler.h"

namespace {

ModDetails invalidDetails;

}

Mod::Mod(const QFileInfo& file) : Resource(file)
{
    m_enabled = (file.suffix() != "disabled");
}

Mod::Mod(const QDir& mods_dir, const Metadata::ModStruct& metadata)
    : Mod(mods_dir.absoluteFilePath(metadata.filename))
{
    m_name = metadata.name;
    m_temp_metadata = std::make_shared<Metadata::ModStruct>(std::move(metadata));
}

auto Mod::enable(bool value) -> bool
{
    if (m_type == ResourceType::UNKNOWN || m_type == ResourceType::FOLDER)
        return false;

    if (m_enabled == value)
        return false;

    QString path = m_file_info.absoluteFilePath();
    QFile file(path);
    if (value) {
        if (!path.endsWith(".disabled"))
            return false;
        path.chop(9);

        if (!file.rename(path))
            return false;
    } else {
        path += ".disabled";

        if (!file.rename(path))
            return false;
    }

    if (status() == ModStatus::NoMetadata)
        setFile(QFileInfo(path));

    m_enabled = value;
    return true;
}

void Mod::setStatus(ModStatus status)
{
    if (m_localDetails) {
        m_localDetails->status = status;
    } else {
        m_temp_status = status;
    }
}
void Mod::setMetadata(const Metadata::ModStruct& metadata)
{
    if (status() == ModStatus::NoMetadata)
        setStatus(ModStatus::Installed);

    if (m_localDetails) {
        m_localDetails->metadata = std::make_shared<Metadata::ModStruct>(std::move(metadata));
    } else {
        m_temp_metadata = std::make_shared<Metadata::ModStruct>(std::move(metadata));
    }
}

auto Mod::destroy(QDir& index_dir, bool preserve_metadata) -> bool
{
    if (!preserve_metadata) {
        qDebug() << QString("Destroying metadata for '%1' on purpose").arg(name());

        if (metadata()) {
            Metadata::remove(index_dir, metadata()->slug);
        } else {
            auto n = name();
            Metadata::remove(index_dir, n);
        }
    }

    return Resource::destroy();
}

auto Mod::details() const -> const ModDetails&
{
    return m_localDetails ? *m_localDetails : invalidDetails;
}

auto Mod::name() const -> QString
{
    auto d_name = details().name;
    if (!d_name.isEmpty())
        return d_name;

    if (metadata())
        return metadata()->name;

    return m_name;
}

auto Mod::version() const -> QString
{
    return details().version;
}

auto Mod::homeurl() const -> QString
{
    return details().homeurl;
}

auto Mod::description() const -> QString
{
    return details().description;
}

auto Mod::authors() const -> QStringList
{
    return details().authors;
}

auto Mod::status() const -> ModStatus
{
    if (!m_localDetails)
        return m_temp_status;
    return details().status;
}

auto Mod::metadata() -> std::shared_ptr<Metadata::ModStruct>
{
    if (m_localDetails)
        return m_localDetails->metadata;
    return m_temp_metadata;
}

auto Mod::metadata() const -> const std::shared_ptr<Metadata::ModStruct>
{
    if (m_localDetails)
        return m_localDetails->metadata;
    return m_temp_metadata;
}

void Mod::finishResolvingWithDetails(std::shared_ptr<ModDetails> details)
{
    m_is_resolving = false;
    m_is_resolved = true;
    m_localDetails = details;

    setStatus(m_temp_status);

    if (m_localDetails && m_temp_metadata && m_temp_metadata->isValid()) {
        setMetadata(*m_temp_metadata);
        m_temp_metadata.reset();
    }
}