#include "CRSMPackCompatibility.hpp"

#include <QFile>

void CRSMPackCompatibility::clear()
{
    auto configVals = configValues;
    *this = CRSMPackCompatibility();
    configValues = configVals;
}

QString CRSMPackCompatibility::linkScenarioPacks(const QString &scenario)
{
    QStringList parts;
    parts.append(scenario);
    QString ret;
    int position = scenario.length();
    while((position = scenario.lastIndexOf('/', position - 1)) != -1)
    {
        parts.append(scenario.left(position));
    }

    QMap<QString, QString> packs = PackDefaultVersion;
    foreach(const QString& filePathPart, parts)
    {
        foreach(const QString& packVersion, ScenarioPacks.value(filePathPart))
        {
            packs[PackVersions[packVersion]] = packVersion;
        }
    }

    foreach(const QString& packName, packs.keys())
    {
        QFile packFile(clonkPath + packName);
        if(packFile.exists())
        {
            packFile.remove();
        }
        if(!QFile::link(clonkPath + packs[packName], clonkPath + packName))
        {
            ret.append("Warning: Could not link pack \"" + packName + "\" to \"" + packs[packName] + "\".\n");
        }
    }

    return ret;
}

QString CRSMPackCompatibility::read(const QString &fileName, const QString& clonkPath, bool writeDefault)
{
    this->clonkPath = clonkPath;
    QString ret = ConfigBase::read(fileName, writeDefault);

    foreach(const QString& packVersion, PackVersions.keys())
    {
        ret.append(checkPackVersion(packVersion, PackVersions[packVersion]));
    }

    foreach(const QString& scenario, ScenarioPacks.keys())
    {
        foreach(const QString& scenarioPack, ScenarioPacks[scenario])
        {
            ret.append(checkScenarioPack(scenarioPack, scenario));
        }
    }

    return ret;
}

QString CRSMPackCompatibility::addPackVersion(const QString &packVersion, const QString &pack)
{
    PackVersions[packVersion] = pack;
    if(!PackDefaultVersion.contains(pack))
    {
        PackDefaultVersion[pack] = packVersion;
    }
    return checkPackVersion(packVersion, pack);
}

QString CRSMPackCompatibility::deletePackVersion(const QString &packVersion)
{
    if(PackVersions.contains(packVersion))
    {
        const QString& pack = PackVersions.value(packVersion);
        PackVersions.remove(packVersion);
        if(PackVersions.values().count(pack) == 0)
        {
            PackDefaultVersion.remove(pack);
        }
        else if(PackDefaultVersion.value(pack) == packVersion)
        {
            PackDefaultVersion[pack] = PackVersions.key(pack);
            return "Warning: Changing default version of \"" + pack + "\" to \"" + PackDefaultVersion[pack] + "\".\n";
        }
        return "";
    }
    else
    {
        return "Error: Can not remove unknown PackVersion.";
    }
}

QString CRSMPackCompatibility::setDefaultPackVersion(const QString &packVersion, const QString &pack)
{
    PackDefaultVersion[pack] = packVersion;
    QString ret = addPackVersion(packVersion, pack);
    return ret;
}

QString CRSMPackCompatibility::addScenarioPackVersion(const QString &packVersion, const QString &scenario)
{
    QString ret = checkScenarioPack(packVersion, scenario);
    if(ret.isEmpty())
    {
        QString pack = PackVersions.value(packVersion);
        foreach(const QString& scenarioPack, ScenarioPacks[scenario])
        {
            if(pack == PackVersions.value(scenarioPack))
            {
                ScenarioPacks[scenario].removeAll(scenarioPack);
                ret = "Overwriting old PackVersion \"" + scenarioPack + "\" with \"" + packVersion + "\".\n";
            }
        }
    }

    ScenarioPacks[scenario].append(packVersion);
    return ret;
}

QString CRSMPackCompatibility::deleteScenarioPackVersion(const QString &packVersion, const QString &scenario)
{
    if(!ScenarioPacks.contains(scenario))
    {
        return "Warning: The scenario \"" + scenario + "\" has no ScenarioPacks defined.\n";
    }
    else if(!ScenarioPacks[scenario].contains(packVersion))
    {
        return "Warning: The scenario \"" + scenario + "\" has no ScenarioPack \"" + packVersion + "\" defined.\n";
    }
    else
    {
        ScenarioPacks[scenario].removeAll(packVersion);
        if(ScenarioPacks[scenario].length() == 0)
        {
            ScenarioPacks.remove(scenario);
        }
        return "";
    }
}

QString CRSMPackCompatibility::checkPackVersion(const QString &packVersion, const QString &pack)
{
    if(!QFile(clonkPath + packVersion).exists())
    {
        return "Warning: PackVersion \"" + packVersion + "\" of pack \"" + pack + "\" does not exist.\n";
    }
    else
    {
        return "";
    }
}

QString CRSMPackCompatibility::checkScenarioPack(const QString &packVersion, const QString &scenario)
{
    if(!PackVersions.contains(packVersion))
    {
        return "Warning: Unknown ScenarioPack \"" + packVersion + "\" of scenario \"" + scenario + "\" will not be linked.\n";
    }
    else
    {
        return "";
    }
}