/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     SmMessage.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: 1 $
 *---------------------------------------------------------------------------*/
#ifndef SM_MESSAGE_H_
#define SM_MESSAGE_H_


#include "../include/SmBase.h"
#include "../include/SmPrimitive.h"


// メッセージのタイプ
enum
{
    SM_MESSAGE_NONE = 0,                    //! なし
    SM_MESSAGE_TUCHPANEL_PRESS = 1,         //! タッチパネルが押された
    SM_MESSAGE_TUCHPANEL_RELEASE = 2,       //! タッチパネルから離れた
    SM_MESSAGE_TUCHPANEL_MOTION = 3,        //! タッチパネルドラッグ中
    SM_MESSAGE_PAD_UPDATE = 4,              //! パッド更新中
    SM_MESSAGE_SCENE_UPDATE = 5,            //! シーン更新中
    SM_MESSAGE_UPDATE_PARAM = 6             //! 更新通知
};
typedef u32 SmMessageType;

//------------------------------------------------------------------------------
// メッセージクラス
class SmMessage : public SmBase
{
public:

    // コンストラクタ
    SmMessage( SmMessage* parent )
               : m_Parent( parent ),
                 m_Child( NULL ),
                 m_Next( NULL ),
                 m_Enable( true ),
                 m_Visible( true ),
                 m_Target( NULL ),
                 m_Id( 0 ){}

    // メッセージを送信する
    virtual bool SendMessage(   SmMessageType   type,
                                void*           object = NULL,
                                uint            targetId = 0 )
    { 
        bool ret = false;

        // 自身を処理
        if ( m_Enable )
        {
            if ( this->ReceveMessage( type, object, targetId ) )
            {
                return true;
            }
        }
        
        // 子がいれば潜る
        if ( m_Enable && m_Child )
        {
            ret = m_Child->sendMessageSub( type, object, targetId );
            if ( ret ) return true;
        }

        return ret;
    }

    // メッセージを受信する
    // true で後続にメッセージを受信させない
    virtual bool ReceveMessage( SmMessageType   type,
                                void*           object = NULL,
                                uint            targetId = 0 )
    { 
        NW_UNUSED_VARIABLE(type);
        NW_UNUSED_VARIABLE(object);
        NW_UNUSED_VARIABLE(targetId);
        return false; 
    }

    // ターゲットを設定する
    void SetTarget( SmMessage* target, uint id )
    {
        m_Target    = target;
        m_Id        = id;
    }

    // 親を設定する
    void SetParent( SmMessage* parent )
    {
        m_Parent = parent;
    }

    // 親を取得する
    SmMessage* GetParent()
    {
        return m_Parent;
    }

    // 子供を追加する
    void AddChild( SmMessage* child )
    {
        child->SetParent( this );

        if ( !m_Child )
        {
            m_Child = child;
        }
        else
        {
            // 子の最後のNextを取得し、
            // そのNextとして登録する
            SmMessage* tmp = m_Child->getNextTail();
            tmp->setNext( child );
        }
    }

    // 各描画処理を行う
    virtual void Render(){ return; }

    // 全てのツリーの描画を行う
    void DrawTree()
    { 
        // 自身を処理
        if ( m_Visible )
        {
            this->Render();
        }

        // 兄弟も処理
        SmMessage* next = this->getNext();
        while( next )
        {
            if ( next->m_Visible )
            {
                next->Render();

                if ( next->m_Child )
                {
                    next->m_Child->DrawTree();
                }
            }
            next = next->getNext();
        }
        
        // 子がいれば潜る
        if ( m_Visible && m_Child )
        {
            m_Child->DrawTree();
        }
    }

    // 有効/無効
    void SetEnable( bool enable )
    {
        // 自身を処理
        m_Enable = enable;
        {
            SetVisible( m_Enable );
        }

        // 子がいれば潜る
        if ( m_Child )
        {
            m_Child->setEnableFunc( enable );
        }

        return;
    }

    bool GetEnable()
    {
        return m_Enable;
    }

    virtual void SetVisible( bool visible )
    {
        m_Visible = visible;
    }

private:
    bool sendMessageSub( SmMessageType   type,
                          void*           object,
                          uint            targetId )
    {
        bool ret = false;

        // 自身を処理
        if ( m_Enable )
        {
            if ( this->ReceveMessage( type, object, targetId ) )
            {
                return true;
            }
        }

        // 兄弟も処理
        SmMessage* next = this->getNext();
        while( next )
        {
            if ( next->m_Enable )
            {
                ret = next->ReceveMessage( type, object, targetId );
                if ( ret ) return true;

                if ( next->m_Child )
                {
                    ret = next->m_Child->sendMessageSub( type, object, targetId );
                    if ( ret ) return true;
                }
            }
            next = next->getNext();
        }
        
        // 子がいれば潜る
        if ( m_Enable && m_Child )
        {
            ret = m_Child->sendMessageSub( type, object, targetId );
            if ( ret ) return true;
        }

        return ret;
    }

    void setEnableFunc( bool enable )
    {
        // 自身を処理
        m_Enable = enable;
        {
            SetVisible( m_Enable );
        }

        // 兄弟も処理
        SmMessage* next = this->getNext();
        while( next )
        {
            next->setEnableFunc( enable );
            next = next->getNext();
        }
        
        // 子がいれば潜る
        if ( m_Child )
        {
            m_Child->setEnableFunc( enable );
        }

        return;
    }

    void setNext( SmMessage* next )
    {
        m_Next = next;
    }

    SmMessage* getNext()
    {
        return m_Next;
    }

    SmMessage* getNextTail()
    {
        if ( !m_Next )
        {
            return this;
        }
        else
        {
            SmMessage* pret = this->getNext();
            while( pret )
            {
                if ( !pret->getNext() ) break;
                pret = pret->getNext();
            }
            return pret;
        }
    }


private:  
    SmMessage*          m_Parent;
    SmMessage*          m_Child;
    SmMessage*          m_Next;

    bool                m_Enable;
    bool                m_Visible;

protected:
    SmMessage*          m_Target;
    uint                m_Id;

};

#endif  // SM_MESSAGE_H_