/*
 * Copyright 2015, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "SettingsParser.h"

#include <string.h>

#include <DriverSettingsMessageAdapter.h>


class AbstractArgsConverter : public DriverSettingsConverter {
public:
        status_t ConvertEmptyFromDriverSettings(
                const driver_parameter& parameter, const char* name, uint32 type,
                BMessage& target)
        {
                if (parameter.parameter_count != 0 || strcmp(name, Name()) == 0)
                        return B_OK;

                BMessage message;
                return target.AddMessage(name, &message);
        }

protected:
        status_t AddSubMessage(const driver_parameter& parameter, int32 index,
                BMessage& target)
        {
                const char* condition = parameter.values[index];
                BMessage args;
                for (index++; index < parameter.value_count; index++) {
                        status_t status = args.AddString("args",
                                parameter.values[index]);
                        if (status != B_OK)
                                return status;
                }
                return target.AddMessage(condition, &args);
        }

        virtual const char* Name() = 0;
};


class ConditionConverter : public AbstractArgsConverter {
public:
        status_t ConvertFromDriverSettings(const driver_parameter& parameter,
                const char* name, int32 index, uint32 type, BMessage& target)
        {
                BMessage message;
                if (strcmp(parameter.name, "if") == 0) {
                        // Parse values directly following "if", with special
                        // handling for the "not" operator.
                        if (index != 0)
                                return B_OK;

                        BMessage* add = &target;
                        bool notOperator = parameter.value_count > 1
                                && strcmp(parameter.values[0], "not") == 0;
                        if (notOperator) {
                                add = &message;
                                index++;
                        }

                        status_t status = AddSubMessage(parameter, index, *add);
                        if (status == B_OK && notOperator)
                                status = target.AddMessage("not", &message);

                        return status;
                }
                if (strcmp(parameter.name, "not") == 0) {
                        if (index != 0)
                                return B_OK;

                        return AddSubMessage(parameter, index, target);
                }

                message.AddString("args", parameter.values[index]);
                return target.AddMessage(parameter.name, &message);
        }

        const char* Name()
        {
                return "if";
        }
};


class EventConverter : public AbstractArgsConverter {
public:
        status_t ConvertFromDriverSettings(const driver_parameter& parameter,
                const char* name, int32 index, uint32 type, BMessage& target)
        {
                BMessage message;
                if (strcmp(parameter.name, "on") == 0) {
                        // Parse values directly following "on"
                        if (index != 0)
                                return B_OK;

                        return AddSubMessage(parameter, index, target);
                }

                message.AddString("args", parameter.values[index]);
                return target.AddMessage(parameter.name, &message);
        }

        const char* Name()
        {
                return "on";
        }
};


class RunConverter : public DriverSettingsConverter {
public:
        status_t ConvertFromDriverSettings(const driver_parameter& parameter,
                const char* name, int32 index, uint32 type, BMessage& target)
        {
                if (parameter.parameter_count == 0)
                        return target.AddString("target", parameter.values[index]);

                return B_NOT_SUPPORTED;
        }

        status_t ConvertEmptyFromDriverSettings(
                const driver_parameter& parameter, const char* name, uint32 type,
                BMessage& target)
        {
                if (parameter.parameter_count != 0)
                        return B_OK;

                return target.AddString("target", name);
        }
};


const static settings_template kConditionTemplate[] = {
        {B_STRING_TYPE, NULL, NULL, true, new ConditionConverter()},
        {B_MESSAGE_TYPE, "not", kConditionTemplate},
        {B_MESSAGE_TYPE, "and", kConditionTemplate},
        {B_MESSAGE_TYPE, "or", kConditionTemplate},
        {0, NULL, NULL}
};

const static settings_template kEventTemplate[] = {
        {B_STRING_TYPE, NULL, NULL, true, new EventConverter()},
        {B_MESSAGE_TYPE, "and", kEventTemplate},
        {B_MESSAGE_TYPE, "or", kEventTemplate},
        {0, NULL, NULL}
};

const static settings_template kPortTemplate[] = {
        {B_STRING_TYPE, "name", NULL, true},
        {B_INT32_TYPE, "capacity", NULL},
};

const static settings_template kEnvTemplate[] = {
        {B_STRING_TYPE, "from_script", NULL, true},
        {B_STRING_TYPE, NULL, NULL},
};

const static settings_template kJobTemplate[] = {
        {B_STRING_TYPE, "name", NULL, true},
        {B_BOOL_TYPE, "disabled", NULL},
        {B_STRING_TYPE, "launch", NULL},
        {B_STRING_TYPE, "requires", NULL},
        {B_BOOL_TYPE, "legacy", NULL},
        {B_MESSAGE_TYPE, "port", kPortTemplate},
        {B_MESSAGE_TYPE, "on", kEventTemplate},
        {B_MESSAGE_TYPE, "if", kConditionTemplate},
        {B_BOOL_TYPE, "no_safemode", NULL},
        {B_BOOL_TYPE, "on_demand", NULL},
        {B_MESSAGE_TYPE, "env", kEnvTemplate},
        {0, NULL, NULL}
};

const static settings_template kTargetTemplate[] = {
        {B_STRING_TYPE, "name", NULL, true},
        {B_BOOL_TYPE, "reset", NULL},
        {B_MESSAGE_TYPE, "on", kEventTemplate},
        {B_MESSAGE_TYPE, "if", kConditionTemplate},
        {B_BOOL_TYPE, "no_safemode", NULL},
        {B_MESSAGE_TYPE, "env", kEnvTemplate},
        {B_MESSAGE_TYPE, "job", kJobTemplate},
        {B_MESSAGE_TYPE, "service", kJobTemplate},
        {0, NULL, NULL}
};

const static settings_template kRunConditionalTemplate[] = {
        {B_STRING_TYPE, NULL, NULL, true, new RunConverter()},
        {0, NULL, NULL}
};

const static settings_template kRunTemplate[] = {
        {B_STRING_TYPE, NULL, NULL, true, new RunConverter()},
        {B_MESSAGE_TYPE, "if", kConditionTemplate},
        {B_MESSAGE_TYPE, "then", kRunConditionalTemplate},
        {B_MESSAGE_TYPE, "else", kRunConditionalTemplate},
        {0, NULL, NULL}
};

const static settings_template kSettingsTemplate[] = {
        {B_MESSAGE_TYPE, "target", kTargetTemplate},
        {B_MESSAGE_TYPE, "job", kJobTemplate},
        {B_MESSAGE_TYPE, "service", kJobTemplate},
        {B_MESSAGE_TYPE, "run", kRunTemplate},
        {0, NULL, NULL}
};


SettingsParser::SettingsParser()
{
}


status_t
SettingsParser::ParseFile(const char* path, BMessage& settings)
{
        DriverSettingsMessageAdapter adapter;
        return adapter.ConvertFromDriverSettings(path, kSettingsTemplate, settings);
}


#ifdef TEST_HAIKU


status_t
SettingsParser::Parse(const char* text, BMessage& settings)
{
        void* driverSettings = parse_driver_settings_string(text);
        if (driverSettings == NULL)
                return B_BAD_VALUE;

        DriverSettingsMessageAdapter adapter;
        status_t status = adapter.ConvertFromDriverSettings(
                *get_driver_settings(driverSettings), kSettingsTemplate, settings);

        unload_driver_settings(driverSettings);
        return status;
}


#endif  // TEST_HAIKU