/**
 * @file llenvadapters.h
 * @brief Declaration of classes managing WindLight and water settings.
 *
 * $LicenseInfo:firstyear=2009&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2011, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_ENVADAPTERS_H
#define LL_ENVADAPTERS_H

#include "v3math.h"
#include "v3color.h"
#include "v4math.h"
#include "llsettingsbase.h"
#include "llsettingssky.h"

class WLColorControl 
{
public:
    inline WLColorControl(LLColor4 color, const std::string& n, const std::string& slider_name = std::string()):
        mColor(color), 
        mName(n), 
        mSliderName(slider_name),
        mHasSliderName(false),
        mIsSunOrAmbientColor(false),
        mIsBlueHorizonOrDensity(false)
    {
        // if there's a slider name, say we have one
        mHasSliderName = !mSliderName.empty();

        // if it's the sun controller
        mIsSunOrAmbientColor = (mSliderName == "WLSunlight" || mSliderName == "WLAmbient");
        mIsBlueHorizonOrDensity = (mSliderName == "WLBlueHorizon" || mSliderName == "WLBlueDensity");
    }

    inline void setColor4(const LLColor4 & val)
    {
        mColor = val;
    }

    inline void setColor3(const LLColor3 & val)
    {
        mColor = val;
    }

    inline LLColor4 getColor4() const
    {
        return mColor;
    }

    inline LLColor3 getColor3(void) const 
    {
        return vec4to3(mColor);
    }

    inline void update(const LLSettingsBase::ptr_t &psetting) const 
    {
        psetting->setValue(mName, mColor);
    }

    inline bool getHasSliderName() const
    {
        return mHasSliderName;
    }

    inline std::string getSliderName() const
    {
        return mSliderName;
    }

    inline bool getIsSunOrAmbientColor() const
    {
        return mIsSunOrAmbientColor;
    }

    inline bool getIsBlueHorizonOrDensity() const
    {
        return mIsBlueHorizonOrDensity;
    }

    inline F32 getRed() const
    {
        return mColor[0];
    }

    inline F32 getGreen() const
    {
        return mColor[1];
    }

    inline F32 getBlue() const
    {
        return mColor[2];
    }

    inline F32 getIntensity() const
    {
        return mColor[3];
    }

    inline void setRed(F32 red)
    {
        mColor[0] = red;
    }

    inline void setGreen(F32 green)
    {
        mColor[1] = green;
    }

    inline void setBlue(F32 blue)
    {
        mColor[2] = blue;
    }

    inline void setIntensity(F32 intensity)
    {
        mColor[3] = intensity;
    }

private:
    LLColor4    mColor;         /// [3] is intensity, not alpha
    std::string mName;			/// name to use to dereference params
    std::string mSliderName;	/// name of the slider in menu
    bool        mHasSliderName;			/// only set slider name for true color types
    bool        mIsSunOrAmbientColor;			/// flag for if it's the sun or ambient color controller
    bool        mIsBlueHorizonOrDensity;		/// flag for if it's the Blue Horizon or Density color controller

};

// float slider control
class WLFloatControl 
{
public:
    inline WLFloatControl(F32 val, const std::string& n, F32 m = 1.0f):
        x(val), 
        mName(n), 
        mult(m)
    {
    }

    inline WLFloatControl &operator = (F32 val) 
    {
        x = val;
        return *this;
    }

    inline operator F32 (void) const 
    {
        return x;
    }

    inline void update(const LLSettingsBase::ptr_t &psetting) const 
    {
        psetting->setValue(mName, x);
    }

    inline F32 getMult() const
    {
        return mult;
    }

    inline void setValue(F32 val)
    {
        x = val;
    }

private:
    F32 x;
    std::string mName;
    F32 mult;
};

class WLXFloatControl
{
public:
    inline WLXFloatControl(F32 val, const std::string& n, F32 b): 
        mExp(val),
        mBase(b),
        mName(n)
    {
    }

    inline WLXFloatControl & operator = (F32 val)
    {
        mExp = log(val) / log(mBase);

        return *this;
    }

    inline operator F32 (void) const
    {
        return pow(mBase, mExp);
    }

    inline void update(const LLSettingsBase::ptr_t &psetting) const
    {
        psetting->setValue(mName, pow(mBase, mExp));
    }

    inline F32 getExp() const
    {
        return mExp;
    }

    inline void setExp(F32 val)
    {
        mExp = val;
    }

    inline F32 getBase() const
    {
        return mBase;
    }

    inline void setBase(F32 val)
    {
        mBase = val;
    }

private:
    F32 mExp;
    F32 mBase;
    std::string mName;
};

class WLVect2Control
{
public:
    inline WLVect2Control(LLVector2 val, const std::string& n): 
        mU(val.mV[0]), 
        mV(val.mV[1]), 
        mName(n)
    {
    }

    inline WLVect2Control & operator = (const LLVector2 & val)
    {
        mU = val.mV[0];
        mV = val.mV[1];

        return *this;
    }

    inline void update(const LLSettingsBase::ptr_t &psetting) const
    {
        psetting->setValue(mName, LLVector2(mU, mV));
    }

    inline F32 getU() const
    {
        return mU;
    }

    inline void setU(F32 val)
    {
        mU = val;
    }

    inline F32 getV() const
    {
        return mV;
    }

    inline void setV(F32 val)
    {
        mV = val;
    }

private:
    F32 mU;
    F32 mV;
    std::string mName;
};

class WLVect3Control
{
public:
    inline WLVect3Control(LLVector3 val, const std::string& n):
        mX(val.mV[0]),
        mY(val.mV[1]),
        mZ(val.mV[2]),
        mName(n)
    {
    }

    inline WLVect3Control & operator = (const LLVector3 & val)
    {
        mX = val.mV[0];
        mY = val.mV[1];
        mZ = val.mV[2];

        return *this;
    }

    inline void update(const LLSettingsBase::ptr_t &psetting) const
    {
        psetting->setValue(mName, LLVector3(mX, mY, mZ));
    }

    inline F32 getX() const
    {
        return mX;
    }

    inline void setX(F32 val)
    {
        mX = val;
    }

    inline F32 getY() const
    {
        return mY;
    }

    inline void setY(F32 val)
    {
        mY = val;
    }

    inline F32 getZ() const
    {
        return mZ;
    }

    inline void setZ(F32 val)
    {
        mZ = val;
    }

private:
    F32 mX;
    F32 mY;
    F32 mZ;
    std::string mName;
};

class LLDensityProfileSettingsAdapter
{
public:
    LLDensityProfileSettingsAdapter(const std::string& config, int layerIndex = 0)
    : mConfig(config)
    , mLayerIndex(layerIndex)
    , mLayerWidth(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH)
    , mExpTerm(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM)
    , mExpScale(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR)
    , mLinTerm(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM)
    , mConstantTerm(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM)
    {}

protected:
    std::string     mConfig;
    int             mLayerIndex;
    WLFloatControl  mLayerWidth; // 0.0 -> to top of atmosphere, however big that may be.
    WLFloatControl  mExpTerm;
    WLFloatControl  mExpScale;
    WLFloatControl  mLinTerm;
    WLFloatControl  mConstantTerm;
};

class LLRayleighDensityProfileSettingsAdapter : public LLDensityProfileSettingsAdapter
{
public:
    LLRayleighDensityProfileSettingsAdapter(int layerIndex = 0)
    : LLDensityProfileSettingsAdapter(LLSettingsSky::SETTING_RAYLEIGH_CONFIG, layerIndex)
    {
    }
};

class LLMieDensityProfileSettingsAdapter : public LLDensityProfileSettingsAdapter
{
public:
    LLMieDensityProfileSettingsAdapter(int layerIndex = 0)
    : LLDensityProfileSettingsAdapter(LLSettingsSky::SETTING_MIE_CONFIG, layerIndex)
    , mAnisotropy(0.8f, LLSettingsSky::SETTING_MIE_ANISOTROPY_FACTOR)
    {
    }

protected:
    WLFloatControl  mAnisotropy;
};

class LLAbsorptionDensityProfileSettingsAdapter : public LLDensityProfileSettingsAdapter
{
public:
    LLAbsorptionDensityProfileSettingsAdapter(int layerIndex = 0)
    : LLDensityProfileSettingsAdapter(LLSettingsSky::SETTING_ABSORPTION_CONFIG, layerIndex)
    {
    }
};

//-------------------------------------------------------------------------
class LLSkySettingsAdapter
{
public:
    typedef std::shared_ptr<LLSkySettingsAdapter> ptr_t;
    
    LLSkySettingsAdapter();

    WLFloatControl  mWLGamma;

    /// Atmospherics
// LEGACY_ATMOSPHERICS
    WLColorControl  mAmbient;
    WLColorControl  mBlueHorizon;
    WLFloatControl  mHazeDensity;
    WLColorControl  mBlueDensity;
    WLFloatControl  mDensityMult;
    WLFloatControl  mDistanceMult;
    WLFloatControl  mHazeHorizon;
    WLFloatControl  mMaxAlt;

    /// Lighting
    WLColorControl  mLightnorm;
    WLColorControl  mSunlight;    
    WLColorControl  mGlow;

    /// Clouds
    WLColorControl  mCloudColor;
    WLColorControl  mCloudMain;
    WLFloatControl  mCloudCoverage;
    WLColorControl  mCloudDetail;    
    WLFloatControl  mCloudScale;
};

class LLWatterSettingsAdapter
{
public:
    typedef std::shared_ptr<LLWatterSettingsAdapter> ptr_t;

    LLWatterSettingsAdapter();

    WLColorControl  mFogColor;
    WLXFloatControl mFogDensity;
    WLFloatControl  mUnderWaterFogMod;

    /// wavelet scales and directions
    WLVect3Control  mNormalScale;
    WLVect2Control  mWave1Dir;
    WLVect2Control  mWave2Dir;

    // controls how water is reflected and refracted
    WLFloatControl  mFresnelScale;
    WLFloatControl  mFresnelOffset;
    WLFloatControl  mScaleAbove;
    WLFloatControl  mScaleBelow;
    WLFloatControl  mBlurMultiplier;

};

#endif // LL_ENVIRONMENT_H