#include "FloatDistribution.h"

#include "Noise.h"

FloatDistribution::FloatDistribution()
    : Framework::ReferenceCounter()
{}

ConstantFloatDistribution::ConstantFloatDistribution(float value)
    : FloatDistribution(),
      value(value)
{}

float ConstantFloatDistribution::getValue(
    int x, int y, int z, int dimenstionId, Noise* zNoise) const
{
    return value;
}

float ConstantFloatDistribution::getValue() const
{
    return value;
}

ConstantFloatDistributionFactory::ConstantFloatDistributionFactory()
    : SubTypeFactory()
{}

JSONObjectValidationBuilder* ConstantFloatDistributionFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredNumber("value")->finishNumber();
}

ConstantFloatDistribution* ConstantFloatDistributionFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new ConstantFloatDistribution(
        (float)zJson->zValue("value")->asNumber()->getNumber());
}

Framework::JSON::JSONObject* ConstantFloatDistributionFactory::toJsonObject(
    ConstantFloatDistribution* zObject) const
{
    Framework::JSON::JSONObject* zJson = new Framework::JSON::JSONObject();
    zJson->addValue(
        "value", new Framework::JSON::JSONNumber(zObject->getValue()));
    return zJson;
}

const char* ConstantFloatDistributionFactory::getTypeToken() const
{
    return "constant";
}

EqualyDistributedFloatDistribution::EqualyDistributedFloatDistribution(
    float minValue, float maxValue)
    : FloatDistribution(),
      minValue(minValue),
      maxValue(maxValue)
{}

float EqualyDistributedFloatDistribution::getValue(
    int x, int y, int z, int dimenstionId, Noise* zNoise) const
{
    return zNoise->getNoise((float)z, (float)x, (float)y)
             * (maxValue - minValue)
         + minValue;
}

float EqualyDistributedFloatDistribution::getMinValue() const
{
    return minValue;
}

float EqualyDistributedFloatDistribution::getMaxValue() const
{
    return maxValue;
}

EqualyDistributedFloatDistributionFactory::
    EqualyDistributedFloatDistributionFactory()
    : SubTypeFactory()
{}

JSONObjectValidationBuilder*
EqualyDistributedFloatDistributionFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredNumber("minValue")
        ->finishNumber()
        ->withRequiredNumber("maxValue")
        ->finishNumber();
}

EqualyDistributedFloatDistribution*
EqualyDistributedFloatDistributionFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new EqualyDistributedFloatDistribution(
        (float)zJson->zValue("minValue")->asNumber()->getNumber(),
        (float)zJson->zValue("maxValue")->asNumber()->getNumber());
}

Framework::JSON::JSONObject*
EqualyDistributedFloatDistributionFactory::toJsonObject(
    EqualyDistributedFloatDistribution* zObject) const
{
    Framework::JSON::JSONObject* zJson = new Framework::JSON::JSONObject();
    zJson->addValue(
        "minValue", new Framework::JSON::JSONNumber(zObject->getMinValue()));
    zJson->addValue(
        "maxValue", new Framework::JSON::JSONNumber(zObject->getMaxValue()));
    return zJson;
}

const char* EqualyDistributedFloatDistributionFactory::getTypeToken() const
{
    return "equalyDistributed";
}