#pragma once

#include "qt-config/ConfigBase.hpp"
#include "ClientInfo.hpp"
#include "CmdFunctionRef.hpp"

struct WishStartStats { // TODO: Implement stats-gathering
    int WishCount = 0;
    int StartCount = 0;
};

struct ScenarioStats {
    WishStartStats Sum;
    QString FileName = "";
    QMap<ClientInfo, WishStartStats> Wishers;
};

struct CommandUseStats {
    int UseCount = 0;
    int SuccessCount = 0;
    int RightsFailCount = 0;
    int SyntaxFailCount = 0;
};

struct UserStats {
    WishStartStats WishSum;
    ClientInfo Client;
    QMap<QString, WishStartStats> ScenarioWishes;
    CommandUseStats CommandSum;
    QMap<QString, CommandUseStats> Commands;
    QMap<QString, int> FailCommands;
};

struct CommandStats {
    CommandUseStats Sum;
    QString Command = "";
    QMap<ClientInfo, CommandUseStats> Users;
};

struct FailCommandStats {
    QString Command = "";
    QMap<ClientInfo, int> Users;
    int Sum = 0;
};

template<>
class ConfigValue<WishStartStats> : public ConfigValueBase {
    WishStartStats& config;
    ConfigValue<int> wishConfig;
    ConfigValue<int> startConfig;
public:
    ConfigValue(WishStartStats& config) : config(config), wishConfig(config.WishCount), startConfig(config.StartCount) {}
    void setValue(const QString& value)
    {
        QStringList parts = value.split(',', Qt::KeepEmptyParts);
        if(parts.length() != 2)
        {
            throw ConfigException("Can not parse corrupt WishStartStats");
        }
        wishConfig.setValue(parts.first());
        startConfig.setValue(parts.at(1));
    }

    QString value()
    {
        return wishConfig.value() + ',' + startConfig.value();
    }
};

template<>
class ConfigValue<CommandUseStats> : public ConfigValueBase {
    CommandUseStats& config;
    ConfigValue<int> useConfig;
    ConfigValue<int> successConfig;
    ConfigValue<int> rightsFailConfig;
    ConfigValue<int> syntaxFailConfig;
public:
    ConfigValue(CommandUseStats& config) : config(config), useConfig(config.UseCount), successConfig(config.SuccessCount), rightsFailConfig(config.RightsFailCount), syntaxFailConfig(config.SyntaxFailCount) {}
    void setValue(const QString& value)
    {
        QStringList parts = value.split(',', Qt::KeepEmptyParts);
        if(parts.length() != 4)
        {
            throw ConfigException("Can not parse corrupt CommandUseStats");
        }
        useConfig.setValue(parts.first());
        successConfig.setValue(parts.at(1));
        rightsFailConfig.setValue(parts.at(2));
        syntaxFailConfig.setValue(parts.at(3));
    }

    QString value()
    {
        return useConfig.value() + ',' + successConfig.value() + ',' + rightsFailConfig.value() + ',' + syntaxFailConfig.value();
    }
};

template<>
class ConfigValue<ScenarioStats> : public ConfigValueBase {
    ScenarioStats& config;
    ConfigValue<WishStartStats> sumConfig;
    ConfigValue<QString> fileNameConfig;
    ConfigValue<QMap<ClientInfo, WishStartStats>> wishersConfig;
public:
    ConfigValue(ScenarioStats& config) : config(config), sumConfig(config.Sum), fileNameConfig(config.FileName), wishersConfig(config.Wishers) {}
    void setValue(const QString& value)
    {
        QStringList parts = Util::splitEscaped(value, '|');
        if(parts.length() != 3)
        {
            throw ConfigException("Can not parse corrupt ScenarioStats");
        }
        sumConfig.setValue(parts.first());
        fileNameConfig.setValue(parts.at(1));
        wishersConfig.setValue(parts.at(2));
    }

    QString value()
    {
        return Util::joinEscape({sumConfig.value(), fileNameConfig.value(), wishersConfig.value()}, '|');
    }
};

template<>
class ConfigValue<UserStats> : public ConfigValueBase {
    UserStats& config;
    ConfigValue<WishStartStats> wishSumConfig;
    ConfigValue<ClientInfo> clientConfig;
    ConfigValue<QMap<QString, WishStartStats>> scenarioWishesConfig;
    ConfigValue<CommandUseStats> commandSumConfig;
    ConfigValue<QMap<QString, CommandUseStats>> commandsConfig;
    ConfigValue<QMap<QString, int>> failCommandsConfig;

public:
    ConfigValue(UserStats& config) : config(config), wishSumConfig(config.WishSum), clientConfig(config.Client), scenarioWishesConfig(config.ScenarioWishes), commandSumConfig(config.CommandSum), commandsConfig(config.Commands), failCommandsConfig(config.FailCommands) {}

    void setValue(const QString& value)
    {
        QStringList parts = Util::splitEscaped(value, '|');
        if(parts.length() != 6)
        {
            throw ConfigException("Can not parse corrupt UserStats");
        }
        wishSumConfig.setValue(parts.first());
        clientConfig.setValue(parts.at(1));
        scenarioWishesConfig.setValue(parts.at(2));
        commandSumConfig.setValue(parts.at(3));
        commandsConfig.setValue(parts.at(4));
        failCommandsConfig.setValue(parts.at(5));
    }

    QString value()
    {
        return Util::joinEscape({wishSumConfig.value(), clientConfig.value(), scenarioWishesConfig.value(), commandSumConfig.value(), commandsConfig.value(), failCommandsConfig.value()}, '|');
    }
};

template<>
class ConfigValue<CommandStats> : public ConfigValueBase {
    CommandStats& config;
    ConfigValue<CommandUseStats> sumConfig;
    ConfigValue<QString> commandConfig;
    ConfigValue<QMap<ClientInfo, CommandUseStats>> usersConfig;

public:
    ConfigValue(CommandStats& config) : config(config), sumConfig(config.Sum), commandConfig(config.Command), usersConfig(config.Users) {}

    void setValue(const QString &value)
    {
        QStringList parts = Util::splitEscaped(value, '|');
        if(parts.length() != 3)
        {
            throw ConfigException("Can not parse corrupt CommandStats");
        }
        sumConfig.setValue(parts.first());
        commandConfig.setValue(parts.at(1));
        usersConfig.setValue(parts.at(2));
    }

    QString value()
    {
        return Util::joinEscape({sumConfig.value(), commandConfig.value(), usersConfig.value()}, '|');
    }

};

template<>
class ConfigValue<FailCommandStats> : public ConfigValueBase {
    FailCommandStats& config;
    ConfigValue<int> sumConfig;
    ConfigValue<QString> commandConfig;
    ConfigValue<QMap<ClientInfo, int>> usersConfig;

public:
    ConfigValue(FailCommandStats& config) : config(config), sumConfig(config.Sum), commandConfig(config.Command), usersConfig(config.Users) {}

    void setValue(const QString &value)
    {
        QStringList parts = Util::splitEscaped(value, '|');
        if(parts.length() != 3)
        {
            throw ConfigException("Can not parse corrupt CommandStats");
        }
        sumConfig.setValue(parts.first());
        commandConfig.setValue(parts.at(1));
        usersConfig.setValue(parts.at(2));
    }

    QString value()
    {
        return Util::joinEscape({sumConfig.value(), commandConfig.value(), usersConfig.value()}, '|');
    }

};

class CRSMStats : public ConfigBase
{
    QString curFileName;
public:
    Map(String, ScenarioStats) Scenarios;
    Map(ClientInfo, UserStats) Users;
    Map(String, CommandStats) Commands;
    Map(String, FailCommandStats) FailCommands;

    CRSMStats() : ConfigBase({
        ConfigVal(Scenarios),
        ConfigVal(Users),
        ConfigVal(Commands),
        ConfigVal(FailCommands)
    }) {}

    void AddScenarioWish(const ClientInfo& client, const QString& scenarioFileName);
    void AddScenarioStart(const ClientInfo& client, const QString& scenarioFileName);
    void AddCommandResult(const ClientInfo& client, const QString& cmd, CmdResult result);
};