// DriverSettings.cpp

#include <new>
#include <stdlib.h>
#include <string.h>

#include <driver_settings.h>

#include <Referenceable.h>

#include "DriverSettings.h"
#include "String.h"

// The parameter values that shall be evaluated to true.
static const char* kTrueValueStrings[]
        = { "1", "true", "yes", "on", "enable", "enabled" };
static const int32 kTrueValueStringCount
        = sizeof(kTrueValueStrings) / sizeof(const char*);


// #pragma mark -
// #pragma mark ----- DriverParameterIterator -----

// Delegate
class DriverParameterIterator::Delegate : public BReferenceable {
public:
                                                                Delegate() : BReferenceable() {}
        virtual                                         ~Delegate() {}

        virtual Delegate*                       Clone() const = 0;

        virtual bool                            HasNext() const = 0;
        virtual bool                            GetNext(DriverParameter* parameter) = 0;
};

// constructor
DriverParameterIterator::DriverParameterIterator()
        : fDelegate(NULL)
{
}

// constructor
DriverParameterIterator::DriverParameterIterator(Delegate* delegate)
        : fDelegate(delegate)
{
}

// copy constructor
DriverParameterIterator::DriverParameterIterator(
        const DriverParameterIterator& other)
        : fDelegate(NULL)
{
        _SetTo(other.fDelegate, true);
}

// destructor
DriverParameterIterator::~DriverParameterIterator()
{
        _SetTo(NULL, false);
}

// HasNext
bool
DriverParameterIterator::HasNext() const
{
        return (fDelegate ? fDelegate->HasNext() : false);
}

// GetNext
bool
DriverParameterIterator::GetNext(DriverParameter* parameter)
{
        if (!fDelegate)
                return false;
        if (fDelegate->CountReferences() > 1) {
                Delegate* clone = fDelegate->Clone();
                if (!clone)
                        return false;
                _SetTo(clone, false);
        }
        return fDelegate->GetNext(parameter);
}

// =
DriverParameterIterator&
DriverParameterIterator::operator=(const DriverParameterIterator& other)
{
        _SetTo(other.fDelegate, true);
        return *this;
}

// _SetTo
void
DriverParameterIterator::_SetTo(Delegate* delegate, bool addReference)
{
        if (fDelegate)
                fDelegate->ReleaseReference();
        fDelegate = delegate;
        if (fDelegate && addReference)
                fDelegate->AcquireReference();
}


// #pragma mark -
// #pragma mark ----- DriverParameterContainer -----

// Iterator
class DriverParameterContainer::Iterator
        : public DriverParameterIterator::Delegate {
public:
        Iterator(const driver_parameter* parameters, int32 count)
                : Delegate(),
                  fParameters(parameters),
                  fCount(count)
        {
        }

        virtual ~Iterator()
        {
        }

        virtual Delegate* Clone() const
        {
                return new(std::nothrow) Iterator(fParameters, fCount);
        }

        virtual bool HasNext() const
        {
                return (fParameters && fCount > 0);
        }

        virtual bool GetNext(DriverParameter* parameter)
        {
                if (fParameters && fCount > 0) {
                        if (parameter)
                                parameter->SetTo(fParameters);
                        fParameters++;
                        fCount--;
                        return true;
                }
                return false;
        }

private:
        const driver_parameter* fParameters;
        int32                                   fCount;
};

// NameIterator
class DriverParameterContainer::NameIterator
        : public DriverParameterIterator::Delegate {
public:
        NameIterator(const driver_parameter* parameters, int32 count,
                const char* name)
                : Delegate(),
                  fParameters(parameters),
                  fCount(count),
                  fName(name)
        {
                _FindNext(false);
        }

        virtual ~NameIterator()
        {
        }

        virtual Delegate* Clone() const
        {
                return new(std::nothrow) NameIterator(fParameters, fCount,
                        fName.GetString());
        }

        virtual bool HasNext() const
        {
                return (fParameters && fCount > 0);
        }

        virtual bool GetNext(DriverParameter* parameter)
        {
                if (fParameters && fCount > 0) {
                        if (parameter)
                                parameter->SetTo(fParameters);
                        _FindNext(true);
                        return true;
                }
                return false;
        }

private:
        void _FindNext(bool skipCurrent)
        {
                if (!fParameters || fCount < 1)
                        return;
                if (skipCurrent) {
                        fParameters++;
                        fCount--;
                }
                while (fCount > 0 && fName != fParameters->name) {
                        fParameters++;
                        fCount--;
                }
        }

private:
        const driver_parameter* fParameters;
        int32                                   fCount;
        String                                  fName;
};

// constructor
DriverParameterContainer::DriverParameterContainer()
{
}

// destructor
DriverParameterContainer::~DriverParameterContainer()
{
}

// CountParameters
int32
DriverParameterContainer::CountParameters() const
{
        int32 count;
        return (GetParametersAndCount(&count) ? count : 0);

}

// GetParameters
const driver_parameter*
DriverParameterContainer::GetParameters() const
{
        int32 count;
        return GetParametersAndCount(&count);
}

// GetParameterAt
bool
DriverParameterContainer::GetParameterAt(int32 index,
        DriverParameter* parameter) const
{
        int32 count;
        if (const driver_parameter* parameters = GetParametersAndCount(&count)) {
                if (index >= 0 && index < count) {
                        if (parameter)
                                parameter->SetTo(parameters + index);
                        return true;
                }
        }
        return false;
}

// FindParameter
bool
DriverParameterContainer::FindParameter(const char* name,
        DriverParameter* parameter) const
{
        if (!name)
                return false;
        int32 count;
        if (const driver_parameter* parameters = GetParametersAndCount(&count)) {
                for (int32 i = 0; i < count; i++) {
                        if (strcmp(name, parameters[i].name) == 0) {
                                if (parameter)
                                        parameter->SetTo(parameters + i);
                                return true;
                        }
                }
        }
        return false;
}

// GetParameterIterator
DriverParameterIterator
DriverParameterContainer::GetParameterIterator() const
{
        int32 count;
        if (const driver_parameter* parameters = GetParametersAndCount(&count)) {
                if (Iterator* iterator = new(std::nothrow) Iterator(parameters, count))
                        return DriverParameterIterator(iterator);
        }
        return DriverParameterIterator();
}

// GetParameterIterator
DriverParameterIterator
DriverParameterContainer::GetParameterIterator(const char* name) const
{
        int32 count;
        if (const driver_parameter* parameters = GetParametersAndCount(&count)) {
                NameIterator* iterator = new(std::nothrow) NameIterator(parameters, count,
                        name);
                if (iterator)
                        return DriverParameterIterator(iterator);
        }
        return DriverParameterIterator();
}

// GetParameterValue
const char*
DriverParameterContainer::GetParameterValue(const char* name,
        const char* unknownValue, const char* noValue) const
{
        DriverParameter parameter;
        if (!FindParameter(name, &parameter))
                return unknownValue;
        return parameter.ValueAt(0, noValue);
}

// GetBoolParameterValue
bool
DriverParameterContainer::GetBoolParameterValue(const char* name,
        bool unknownValue, bool noValue) const
{
        DriverParameter parameter;
        if (!FindParameter(name, &parameter))
                return unknownValue;
        return parameter.BoolValueAt(0, noValue);
}

// GetInt32ParameterValue
int32
DriverParameterContainer::GetInt32ParameterValue(const char* name,
        int32 unknownValue, int32 noValue) const
{
        DriverParameter parameter;
        if (!FindParameter(name, &parameter))
                return unknownValue;
        return parameter.Int32ValueAt(0, noValue);
}

// GetInt64ParameterValue
int64
DriverParameterContainer::GetInt64ParameterValue(const char* name,
        int64 unknownValue, int64 noValue) const
{
        DriverParameter parameter;
        if (!FindParameter(name, &parameter))
                return unknownValue;
        return parameter.Int64ValueAt(0, noValue);
}


// #pragma mark -
// #pragma mark ----- DriverSettings -----

// constructor
DriverSettings::DriverSettings()
        : DriverParameterContainer(),
          fSettingsHandle(NULL),
          fSettings(NULL)
{
}

// destructor
DriverSettings::~DriverSettings()
{
        Unset();
}

// Load
status_t
DriverSettings::Load(const char* driverName)
{
        Unset();
        fSettingsHandle = load_driver_settings(driverName);
        if (!fSettingsHandle)
                return B_ENTRY_NOT_FOUND;
        fSettings = get_driver_settings(fSettingsHandle);
        if (!fSettings) {
                Unset();
                return B_ERROR;
        }
        return B_OK;
}

// Unset
void
DriverSettings::Unset()
{
        if (fSettingsHandle)
                unload_driver_settings(fSettingsHandle);
        fSettingsHandle = NULL;
        fSettings = NULL;
}

// GetParametersAndCount
const driver_parameter*
DriverSettings::GetParametersAndCount(int32* count) const
{
        if (!fSettings)
                return NULL;
        *count = fSettings->parameter_count;
        return fSettings->parameters;
}


// #pragma mark -
// #pragma mark ----- DriverParameter -----

// constructor
DriverParameter::DriverParameter()
        : DriverParameterContainer(),
          fParameter(NULL)
{
}

// destructor
DriverParameter::~DriverParameter()
{
}

// SetTo
void
DriverParameter::SetTo(const driver_parameter* parameter)
{
        fParameter = parameter;
}

// GetName
const char*
DriverParameter::GetName() const
{
        return (fParameter ? fParameter->name : NULL);
}

// CountValues
int32
DriverParameter::CountValues() const
{
        return (fParameter ? fParameter->value_count : 0);
}

// GetValues
const char* const*
DriverParameter::GetValues() const
{
        return (fParameter ? fParameter->values : 0);
}

// ValueAt
const char*
DriverParameter::ValueAt(int32 index, const char* noValue) const
{
        if (!fParameter || index < 0 || index >= fParameter->value_count)
                return noValue;
        return fParameter->values[index];
}

// BoolValueAt
bool
DriverParameter::BoolValueAt(int32 index, bool noValue) const
{
        const char* value = ValueAt(index, NULL);
        if (!value)
                return noValue;
        for (int32 i = 0; i < kTrueValueStringCount; i++) {
                if (strcmp(value, kTrueValueStrings[i]) == 0)
                        return true;
        }
        return false;
}

// Int32ValueAt
int32
DriverParameter::Int32ValueAt(int32 index, int32 noValue) const
{
        const char* value = ValueAt(index, NULL);
        if (!value)
                return noValue;
        return atol(value);
}

// Int64ValueAt
int64
DriverParameter::Int64ValueAt(int32 index, int64 noValue) const
{
        const char* value = ValueAt(index, NULL);
        if (!value)
                return noValue;
        return strtoll(value, NULL, 10);
}

// GetParametersAndCount
const driver_parameter*
DriverParameter::GetParametersAndCount(int32* count) const
{
        if (!fParameter)
                return NULL;
        *count = fParameter->parameter_count;
        return fParameter->parameters;
}