/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     PhtselMenu.h

  Copyright (C)2009-2012 Nintendo Co., Ltd.  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.

  $Rev:$
 *---------------------------------------------------------------------------*/

#ifndef NN_SAMPLE_DEMOS_PHTSEL_PHTSEL_MENU_H_
#define NN_SAMPLE_DEMOS_PHTSEL_PHTSEL_MENU_H_

#include "Menu.h"

#include <nn/phtsel.h>

#pragma diag_suppress 2530  // Suppress padding warnings
#pragma diag_suppress 1301  // Suppress padding warnings

////////////////////////////////////////////////////////////////////////////////////////////////
/// Date/time definition item
///
////////////////////////////////////////////////////////////////////////////////////////////////
class DateTimeItem : public ItemBase
{
public:
    typedef nn::phtsel::DateTimeConvert  value_type;
    
public:
    DateTimeItem( const char* pName )
        : ItemBase(pName, 1, true)
        , m_nParamSelect(0)
    {
        m_nParams[Param_Year ] = 0;
        m_nParams[Param_Month] = 1;
        m_nParams[Param_Day  ] = 1;
        m_nParams[Param_Hour ] = 0;
        m_nParams[Param_Min  ] = 0;
        m_nParams[Param_Sec  ] = 0;
    }
    
    /// Manipulate individual items
    virtual void         Proc( const PadEx& padEx )
    {
        ItemBase::Proc(padEx);
        
        if( !IsDetailEditMode() ) return;
        
        const bit32  repeat = padEx.GetRepeat();
        
        // Select parameter
        if ( (repeat & (nn::hid::BUTTON_LEFT)) )
        {
            --m_nParamSelect;
            if( m_nParamSelect < 0 ) m_nParamSelect = Param_Num-1;
        }
        else if ( (repeat & (nn::hid::BUTTON_RIGHT)) )
        {
            ++m_nParamSelect;
            if( m_nParamSelect >= Param_Num ) m_nParamSelect = 0;
        }
        
        // Change value
        if ( (repeat & (nn::hid::BUTTON_UP | nn::hid::BUTTON_DOWN)) )
        {
            s32  inc = ((repeat & nn::hid::BUTTON_UP) ? 1 : 0) - ((repeat & nn::hid::BUTTON_DOWN) ? 1 : 0);
            m_nParams[m_nParamSelect] += inc;
            
            // Check value range
            s32  minParams[Param_Num];
            s32  maxParams[Param_Num];
            {
                nn::phtsel::DateTimeConvert::GetMinSeconds().ConvertToParam(
                    &minParams[Param_Year ],
                    &minParams[Param_Month],
                    &minParams[Param_Day  ],
                    &minParams[Param_Hour ],
                    &minParams[Param_Min  ],
                    &minParams[Param_Sec  ]
                );
                nn::phtsel::DateTimeConvert::GetMaxSeconds().ConvertToParam(
                    &maxParams[Param_Year ],
                    &maxParams[Param_Month],
                    &maxParams[Param_Day  ],
                    &maxParams[Param_Hour ],
                    &maxParams[Param_Min  ],
                    &maxParams[Param_Sec  ]
                );
            }
            
            for( s32 i=0; i<Param_Num; ++i )
            {
                if( m_nParams[i] < minParams[i] ) m_nParams[i] = maxParams[i];
                else if( m_nParams[i] > maxParams[i] ) m_nParams[i] = minParams[i];
            }
            
            // Check whether day is valid
            nn::phtsel::DateTimeConvert  dtc;
            while(
                m_nParams[Param_Day] >= 1 && 
                !dtc.ConvertFromParam(
                    m_nParams[Param_Year ],
                    m_nParams[Param_Month],
                    m_nParams[Param_Day  ],
                    m_nParams[Param_Hour ],
                    m_nParams[Param_Min  ],
                    m_nParams[Param_Sec  ]
                )
            )
            {
                if( inc > 0 && m_nParamSelect == Param_Day ){
                    m_nParams[Param_Day] = 1;
                    break;
                }
                else{
                    --m_nParams[Param_Day];
                }
            }
        }
    }
    
    /// Render
    virtual void  Draw( demo::RenderSystemDrawing& df, s32 x, s32 y, bool bSelectItem ) const
    {
        DrawItemNameCommon( df, x, y, bSelectItem );
        df.SetColor(1.0f, 1.0f, 1.0f);
        
        s32  x2 = x+160;
        DrawParam( df, x2, y, "%04d", Param_Year ); x2 += 8*4;
        df.DrawText( x2, y, "-" ); x2 += 8;
        DrawParam( df, x2, y, "%02d", Param_Month ); x2 += 8*2;
        df.DrawText( x2, y, "-" ); x2 += 8;
        DrawParam( df, x2, y, "%02d", Param_Day ); x2 += 8*2;
        
        x2 += 8;
        
        DrawParam( df, x2, y, "%02d", Param_Hour ); x2 += 8*2;
        df.DrawText( x2, y, ":" ); x2 += 8;
        DrawParam( df, x2, y, "%02d", Param_Min ); x2 += 8*2;
        df.DrawText( x2, y, ":" ); x2 += 8;
        DrawParam( df, x2, y, "%02d", Param_Sec ); x2 += 8*2;
    }
    
    //==============================
    
    /// Get value
    value_type  GetSelectValue() const
    {
        value_type  ret;
        bool bSuccess = ret.ConvertFromParam(
            m_nParams[Param_Year ],
            m_nParams[Param_Month],
            m_nParams[Param_Day  ],
            m_nParams[Param_Hour ],
            m_nParams[Param_Min  ],
            m_nParams[Param_Sec  ]
        );
        if( !bSuccess )
        {
            NN_LOG("bad DateTime.\n");
            ret.SetSeconds(0);
        }
        return ret;
    }
    
    /// Set selection from value
    void  SetSelectValue( const value_type& value )
    {
        value.ConvertToParam(
            &m_nParams[Param_Year ],
            &m_nParams[Param_Month],
            &m_nParams[Param_Day  ],
            &m_nParams[Param_Hour ],
            &m_nParams[Param_Min  ],
            &m_nParams[Param_Sec  ]
        );
    }
    
private:
    enum Param
    {
        Param_Year ,
        Param_Month,
        Param_Day  ,
        Param_Hour ,
        Param_Min  ,
        Param_Sec  ,
        
        Param_Num
    };
private:
    void  DrawParam( demo::RenderSystemDrawing& df, s32 x, s32 y, const char* format, Param param ) const
    {
        if( IsDetailEditMode() && m_nParamSelect == param ){
            df.SetColor(1.0f, 0.5f, 0.1f);
        }
        df.DrawText( x, y, format, m_nParams[param] );
        df.SetColor(1.0f, 1.0f, 1.0f);
    }
private:
    s32  m_nParamSelect;
    s32  m_nParams[Param_Num];
};

////////////////////////////////////////////////////////////////////////////////////////////////
/// Game title
///
////////////////////////////////////////////////////////////////////////////////////////////////
class TitleIdItem : public ItemBase
{
public:
    typedef u32  value_type;
    static const s32  cIdMaxNum = nn::phtsel::PhtselInput::TITLE_UNIQUE_ID_MAX_NUM;
    
public:
    TitleIdItem( const char* pName ) 
        : ItemBase(pName, cIdMaxNum, true)
        , m_nDigitSelect(0)
    {
        ResetValueAll();
    }
    
    /// Manipulate individual items
    virtual void  Proc( const PadEx& padEx )
    {
        if( !IsDetailEditMode() )
        {
            ItemBase::Proc(padEx);
            return;
        }
        
        const bit32  repeat = padEx.GetRepeat();
        
        // Select digit
        if ( (repeat & (nn::hid::BUTTON_LEFT)) )
        {
            --m_nDigitSelect;
            if( m_nDigitSelect < 0 ) m_nDigitSelect = cDigitNum-1;
        }
        else if ( (repeat & (nn::hid::BUTTON_RIGHT)) )
        {
            ++m_nDigitSelect;
            if( m_nDigitSelect >= cDigitNum ) m_nDigitSelect = 0;
        }
        
        // Change value
        if ( (repeat & (nn::hid::BUTTON_UP | nn::hid::BUTTON_DOWN)) )
        {
            const s32  inc = ((repeat & nn::hid::BUTTON_UP) ? 1 : 0) - ((repeat & nn::hid::BUTTON_DOWN) ? 1 : 0);
            
            const s32 digit = cDigitNum-1 - m_nDigitSelect;
            value_type  value = GetSelectValue();
            s32  digitValue = (value >> (4*digit)) % 16;
            
            digitValue += inc;
            if( digitValue > 15 ) digitValue = 0;
            else if( digitValue < 0 ) digitValue = 15;
            
            digitValue <<= (4*digit);
            value &= ~static_cast<value_type>(15 << (4*digit));
            value |= static_cast<value_type>(digitValue);
            
            m_aValue[GetSelectIndex()] = value;
        }
    }
    
    /// Render
    virtual void  Draw( demo::RenderSystemDrawing& df, s32 x, s32 y, bool bSelectItem ) const
    {
        DrawItemNameCommon( df, x, y, bSelectItem );
        
        s32  x2 = x+160;
        df.DrawText( x2, y, "%3d/%3d:", GetSelectIndex()+1, GetValueNum() );
        x2 += 8*8;
        
        df.SetColor(1.0f, 1.0f, 1.0f);
        
        value_type  value = GetSelectValue();
        s32  nShift = 4*(cDigitNum-1);
        for( s32 i=0; i<cDigitNum && nShift>=0; ++i )
        {
            if( IsDetailEditMode() && i == m_nDigitSelect ){
                df.SetColor(1.0f, 0.5f, 0.1f);
            }
            else{
                df.SetColor(1.0f, 1.0f, 1.0f);
            }
            
            value_type  n = (value >> nShift) % 16;
            df.DrawText( x2, y, "%X", n );
            x2 += 8;
            nShift -= 4;
        }
    }
    
    //==============================
    
    /// Get value
    value_type  GetValue( s32 idx ) const
    {
        NN_ASSERT( idx>=0 && idx<GetValueNum() );
        return m_aValue[idx];
    }
    
    /// Get selected value
    value_type  GetSelectValue() const
    {
        return GetValue( GetSelectIndex() );
    }
    
    /// Initialize
    void  ResetValueAll()
    {
        std::memset(m_aValue, 0, sizeof(m_aValue));
        SetSelectIndex(0);
    }
    
private:
    static const s32  cDigitNum = 5;
    
private:
    value_type  m_aValue[cIdMaxNum];
    s32  m_nDigitSelect;
};

#pragma diag_default 1301  // End suppressing padding warnings
#pragma diag_default 2530  // End suppressing padding warnings

/* NN_SAMPLE_DEMOS_PHTSEL_PHTSEL_MENU_H_ */
#endif

/*---------------------------------------------------------------------------*
  End of file
 *---------------------------------------------------------------------------*/