/*
 * Copyright 2003-2004 Waldemar Kornewald. All rights reserved.
 * Copyright 2017 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "MessageDriverSettingsUtils.h"

#include <PPPDefs.h>
#include <settings_tools.h>
#include <File.h>
#include <Message.h>
#include <String.h>

#include <cstdio>


static bool AddParameters(const BMessage& message, driver_settings *to);


bool
FindMessageParameter(const char *name, const BMessage& message, BMessage *save,
        int32 *startIndex)
{
        // XXX: this should be removed when we can replace BMessage with something better
        BString string;
        int32 index = startIndex ? *startIndex : 0;
        for(; message.FindMessage(MDSU_PARAMETERS, index, save) == B_OK; index++) {
                if(save->FindString(MDSU_NAME, &string) == B_OK
                                && string.ICompare(name) == 0) {
                        if(startIndex)
                                *startIndex = index;
                        return true;
                }
        }

        return false;
}


static
bool
AddValues(const BMessage& message, driver_parameter *parameter)
{
        const char *value;
        for(int32 index = 0; message.FindString(MDSU_VALUES, index, &value) == B_OK;
                        index++)
                if(!add_driver_parameter_value(value, parameter))
                        return false;

        return true;
}


inline
bool
AddParameters(const BMessage& message, driver_parameter *to)
{
        if(!to)
                return false;

        return AddParameters(message,
                reinterpret_cast<driver_settings*>(&to->parameter_count));
}


static
bool
AddParameters(const BMessage& message, driver_settings *to)
{
        const char *name;
        BMessage current;
        driver_parameter *parameter;
        for(int32 index = 0; message.FindMessage(MDSU_PARAMETERS, index,
                        &current) == B_OK; index++) {
                name = current.FindString(MDSU_NAME);
                parameter = new_driver_parameter(name);
                if(!AddValues(current, parameter))
                        return false;

                AddParameters(current, parameter);
                add_driver_parameter(parameter, to);
        }

        return true;
}


driver_settings*
MessageToDriverSettings(const BMessage& message)
{
        driver_settings *settings = new_driver_settings();

        if(!AddParameters(message, settings)) {
                free_driver_settings(settings);
                return NULL;
        }

        return settings;
}


static
bool
AddParameter(const driver_parameter *parameter, BMessage *message)
{
        if(!parameter || !message)
                return false;

        if(parameter->name)
                message->AddString(MDSU_NAME, parameter->name);
        else
                return false;

        for(int32 index = 0; index < parameter->value_count; index++)
                if(parameter->values[index])
                        message->AddString(MDSU_VALUES, parameter->values[index]);

        for(int32 index = 0; index < parameter->parameter_count; index++) {
                BMessage parameterMessage;
                AddParameter(&parameter->parameters[index], &parameterMessage);
                message->AddMessage(MDSU_PARAMETERS, &parameterMessage);
        }

        return true;
}


bool
ReadMessageDriverSettings(const char *name, BMessage *message)
{
        if(!name || !message)
                return false;

        void *handle = load_driver_settings(name);
        if(!handle)
                return false;
        const driver_settings *settings = get_driver_settings(handle);
        if(!settings) {
                unload_driver_settings(handle);
                return false;
        }

        for(int32 index = 0; index < settings->parameter_count; index++) {
                BMessage parameter;
                AddParameter(&settings->parameters[index], &parameter);
                message->AddMessage(MDSU_PARAMETERS, &parameter);
        }

        unload_driver_settings(handle);

        return true;
}


static
void
EscapeWord(BString& word)
{
        word.ReplaceAll("\\", "\\\\");
        word.ReplaceAll("#", "\\#");
        word.ReplaceAll("\"", "\\\"");
        word.ReplaceAll("\'", "\\\'");
}


static
bool
WriteParameter(BFile& file, const BMessage& parameter, int32 level)
{
        const char *name;
        if(parameter.FindString(MDSU_NAME, &name) != B_OK || !name)
                return false;

        BString line, word(name);
        EscapeWord(word);
        bool needsEscaping = word.FindFirst(' ') >= 0;
        line.SetTo('\t', level);
        if(needsEscaping)
                line << '\"';
        line << word;
        if(needsEscaping)
                line << '\"';

        for(int32 index = 0; parameter.FindString(MDSU_VALUES, index, &name) == B_OK;
                        index++)
                if(name) {
                        line << ' ';
                        word = name;
                        EscapeWord(word);
                        needsEscaping = word.FindFirst(' ') >= 0;
                        if(needsEscaping)
                                line << '\"';
                        line << word;
                        if(needsEscaping)
                                line << '\"';
                }

        type_code type;
        int32 parameterCount;
        parameter.GetInfo(MDSU_PARAMETERS, &type, &parameterCount);

        if(parameterCount > 0)
                line << " {";

        line << '\n';
        file.Write(line.String(), line.Length());

        if(parameterCount > 0) {
                BMessage subParameter;
                for(int32 index = 0; parameter.FindMessage(MDSU_PARAMETERS, index,
                                &subParameter) == B_OK; index++)
                        WriteParameter(file, subParameter, level + 1);

                line.SetTo('\t', level);
                line << "}\n";
                file.Write(line.String(), line.Length());
        }

        return true;
}


bool
WriteMessageDriverSettings(BFile& file, const BMessage& message)
{
        if(file.InitCheck() != B_OK || !file.IsWritable())
                return false;

        file.SetSize(0);
        file.Seek(0, SEEK_SET);

        BMessage parameter;
        for(int32 index = 0; message.FindMessage(MDSU_PARAMETERS, index, &parameter) == B_OK;
                        index++) {
                if(index > 0)
                        file.Write("\n", 1);
                WriteParameter(file, parameter, 0);
        }

        return true;
}