/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     demolib.h

  Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Revision:$
 *---------------------------------------------------------------------------*/

#ifndef NW_SND_DEMO_DEMOLIB_H_
#define NW_SND_DEMO_DEMOLIB_H_

#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <nw/font.h>
#include <nw/font/font_RectDrawer.h>
#include <nw/demo.h>
#include <nw/ut.h>

#ifdef NW_PLATFORM_CTRWIN
    #define NW_SND_DEMO_PATH_PREFIX "romfiles/"
#else
    #define NW_SND_DEMO_PATH_PREFIX "rom:/"
#endif

namespace nw {
namespace snd {
namespace demolib {

class AppBase
{
public:
    void Initialize();
    void Finalize();
    void Run();

protected:
    virtual void OnInitialize() {}
    virtual void OnFinalize() {}
    virtual void OnDrawUpLCD( nw::font::TextWriter& ) {}
    virtual void OnDrawDownLCD( nw::font::TextWriter& ) {}
    virtual void OnUpdatePad( nw::demo::Pad& ) {}
    virtual void OnUpdate() {}

    virtual void LoadDspComponent();

protected:
    AppBase();
    void* MemAlloc( size_t size, u8 alignment = 4 );
    void MemFree( void* memory );
    void SetDraw( bool enable ) { m_IsDraw = enable; }
    bool IsDraw() const { return m_IsDraw; }

private:
    void InitializeSDK();
    void FinalizeSDK();

    bool InitializeFont();
    void FinalizeFont();

    void InitializeShaders();
    void FinalizeShaders();

    void InitializeDrawStringBuffer();
    void FinalizeDrawStringBuffer();
    
    void InitializeGX();
    void InitializeDraw( int width, int height );
    void SetupTextCamera( nw::font::RectDrawer* pDrawer, int width, int height );

    void DrawStringPreProcess(
            nw::font::TextWriter& writer,
            const nw::gfx::FrameBufferObject& frameBufferObject,
            int width,
            int height );
    void DrawStringPostProcess(
            nw::font::TextWriter& writer,
            int width,
            int height );

    void Draw();
    void Update();
    void UpdatePad();

    nw::font::DispStringBuffer* AllocDispStringBuffer( int charMax );

    nw::font::ResFont m_Font;
    nw::font::RectDrawer m_Drawer;

    void* m_pMemoryForRomFileSystem;
    void* m_pMemoryForDrawBuffer;
    nw::font::DispStringBuffer* m_pDrawStringBufferUpperLcd;
    nw::font::DispStringBuffer* m_pDrawStringBufferLowerLcd;

    bool m_IsDraw;
};

class Param
{
public:
    Param( const char* name ) : m_pName( name ) {}
    virtual ~Param() {}

    const char* GetName() const { return m_pName; }

    virtual const char* GetValueString() = 0;

    virtual f32 GetF32Value() const = 0;
    virtual int GetIntValue() const = 0;
    virtual bool GetBoolValue() const = 0;

    virtual void Incr( int ratio ) = 0;
    virtual void Decr( int ratio ) = 0;
    virtual void Reset() = 0;

protected:
    char m_ValueStringBuffer[16];

private:
    const char* m_pName;
};

class ParamInt : public Param
{
public:
    ParamInt( const char* name, int init, int step, int min, int max )
    : Param( name ),
      m_Init( init ),
      m_Step( step ),
      m_Min( min ),
      m_Max( max ),
      m_Value( init )
    {}

    virtual const char* GetValueString()
    {
        std::snprintf( m_ValueStringBuffer, 16, "%7d", m_Value );
        return m_ValueStringBuffer;
    }

    virtual f32 GetF32Value() const { return (f32)( m_Value ); }
    virtual int GetIntValue() const { return m_Value; }
    virtual bool GetBoolValue() const { return ( m_Value != 0 ); }

    virtual void Incr( int ratio ) { m_Value = nw::ut::Min( m_Value + m_Step * ratio, m_Max); }
    virtual void Decr( int ratio ) { m_Value = nw::ut::Max( m_Value - m_Step * ratio, m_Min); }
    virtual void Reset() { m_Value = m_Init; }

private:
    int m_Init, m_Step, m_Min, m_Max, m_Value;
};

class ParamF32 : public Param
{
public:
    ParamF32( const char* name, f32 init, f32 step, f32 min, f32 max )
    : Param( name ),
      m_Init( init ),
      m_Step( step ),
      m_Min( min ),
      m_Max( max ),
      m_Value( init )
    {}

    virtual const char* GetValueString()
    {
        std::snprintf( m_ValueStringBuffer, 16, "% 7.2f", m_Value );
        return m_ValueStringBuffer;
    }

    virtual f32 GetF32Value() const { return m_Value; }
    virtual int GetIntValue() const { return (int)(m_Value); }
    virtual bool GetBoolValue() const { return ( m_Value != 0.0f ); }

    virtual void Incr( int ratio ) { m_Value = nw::ut::Min( m_Value + m_Step * ratio, m_Max ); }
    virtual void Decr( int ratio ) { m_Value = nw::ut::Max( m_Value - m_Step * ratio, m_Min ); }
    virtual void Reset() { m_Value = m_Init; }

private:
    f32 m_Init, m_Step, m_Min, m_Max, m_Value;
};

class ParamBool : public Param
{
public:
    ParamBool( const char* name, int init )
    : Param( name ),
      m_Init( init ),
      m_Value( init )
    {}

    virtual const char* GetValueString()
    {
        return m_Value ? "     on": "    off";
    }

    virtual f32 GetF32Value() const { return m_Value != 0.0f; }
    virtual int GetIntValue() const { return m_Value != 0; }
    virtual bool GetBoolValue() const { return m_Value; }

    virtual void Incr( int /*ratio*/ ) { m_Value = ! m_Value; }
    virtual void Decr( int /*ratio*/ ) { m_Value = ! m_Value; }
    virtual void Reset() { m_Value = m_Init; }

private:
    bool m_Init, m_Value;
};




} // namespace nw::snd::demolib
} // namespace nw::snd
} // namespace nw

#endif /* NW_SND_DEMO_DEMOLIB_H_ */