/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef plWindow_h_inc
#define plWindow_h_inc

class plControl;

#include <strstream>


class plWindow
: public plClass    // plClass _must_ be the first base class in list.
, public plConfigValueBase
{
public:
    HWND                    fhWnd;
    WORD                    fControlID;
    WORD                    fTopControlID;
    bool                    fDestroyed;
    bool                    fMdiChild;
    plWindow *              fOwnerWindow;
    std::vector<plControl*> fControls;
    HWND & Handle() { return fhWnd;}
    const HWND & Handle() const { return fhWnd;}
    bool                    fEdited;

    static int _ModalCount;
    static std::vector<plWindow*> _Windows;
    static std::vector<plWindow*> _DeleteWindows;
    static LONG APIENTRY StaticWndProc(HWND hWnd, unsigned int message, unsigned int wParam, LONG lParam )
    {
        // look for this hwnd in window list
        int i;
        for(i=0; i<_Windows.size(); i++ )
            if( _Windows[i]->Handle()==hWnd )
                break;
        if (i==_Windows.size())
        {
//          hsStatusMessage("hwnd not found in _Windows.\n");
        }

        // if window not found and this is WM_NCCREATE or WM_INITDIALOG msg...
        if( i==_Windows.size() && (message==WM_NCCREATE || message==WM_INITDIALOG || message==WM_ACTIVATE) )
        {
            // get the plWindow object
            plWindow * WindowCreate
            =   message!=WM_NCCREATE
            ?   (plWindow*)lParam
            :   (GetWindowLong(hWnd,GWL_EXSTYLE) & WS_EX_MDICHILD)
            ?   (plWindow*)((MDICREATESTRUCT*)((CREATESTRUCT*)lParam)->lpCreateParams)->lParam
            :   (plWindow*)((CREATESTRUCT*)lParam)->lpCreateParams;
            CHECK(WindowCreate);
            CHECK(!WindowCreate->Handle());

            // set the hwnd for this plWindow
            WindowCreate->Handle() = hWnd;
            // look for this plWindow in window list
            for( i=0; i<_Windows.size(); i++ )
                if( _Windows[i]==WindowCreate )
                    break;
            if (i==_Windows.size())
            {
                hsStatusMessage("plWindow not found in _Windows.\n");
            }
            CHECK(i<_Windows.size());
        }
        // if window not found and message is not WM_NCCREATE or WM_INITDIALOG msg...
        if( i==_Windows.size() )
        {
            // Gets through before WM_NCCREATE: WM_GETMINMAXINFO
            return DefWindowProc( hWnd, message, wParam, lParam );
        }
        else
        {
            // call the plWindow class's message handler
            return _Windows[i]->WndProc( message, wParam, lParam );         
        }
    }
    static WNDPROC RegisterWindowClass( const wchar_t * name, DWORD style, int iconId=0 )
    {
#ifdef UNICODE
        WNDCLASSEX cls;
        HSMemory::ClearMemory( &cls, sizeof(cls) );
        cls.cbSize          = sizeof(cls);
        cls.style           = style;
        cls.lpfnWndProc     = StaticWndProc;
        cls.hInstance       = plWndCtrls::Instance();
        cls.hIcon           = LoadIcon(plWndCtrls::Instance(),MAKEINTRESOURCE(iconId));
        cls.lpszClassName   = name;
        cls.hIconSm         = LoadIcon(plWndCtrls::Instance(),MAKEINTRESOURCE(iconId));
        CHECK(RegisterClassEx( &cls ));
#else
        char *cName = hsWStringToString(name);
        WNDCLASSEX cls;
        HSMemory::ClearMemory( &cls, sizeof(cls) );
        cls.cbSize          = sizeof(cls);
        cls.style           = style;
        cls.lpfnWndProc     = StaticWndProc;
        cls.hInstance       = plWndCtrls::Instance();
        cls.hIcon           = LoadIcon(plWndCtrls::Instance(),MAKEINTRESOURCE(iconId));
        cls.lpszClassName   = cName;
        cls.hIconSm         = LoadIcon(plWndCtrls::Instance(),MAKEINTRESOURCE(iconId));
        CHECK(RegisterClassEx( &cls ));
        delete [] cName;
#endif
        return nil;
    }

    plWindow( plWindow * ownerWindow=nil )
    :   fhWnd           (nil)
    ,   fControlID      (0)
    ,   fTopControlID   (FIRST_AUTO_CONTROL)
    ,   fDestroyed      (0)
    ,   fMdiChild       (0)
    ,   fOwnerWindow    (ownerWindow)
    ,   fEdited         (false)
    {
        fReadEvaluate = plEvaluate(this,(TEvaluate)HasConfigName);
        fWriteEvaluate = plEvaluate(this,(TEvaluate)HasConfigName);
    }
    virtual ~plWindow()
    {
        MaybeDestroy();
        std::vector<plWindow*>::iterator it = std::find(_DeleteWindows.begin(),_DeleteWindows.end(),this);
        if (it!=_DeleteWindows.end())
            _DeleteWindows.erase(it);
    }

    plRect GetClientRect() const
    {
        RECT R;
        ::GetClientRect( Handle(), &R );
        return plRect( R );
    }
    plRect GetUpdateRect(bool erase) const
    {
        RECT R;
        ::GetUpdateRect(*this,&R,erase);
        return plRect(R);
    }
    void MoveWindow( plRect R, bool bRepaint )
    {
        ::MoveWindow( Handle(), R.Min.X, R.Min.Y, R.Width(), R.Height(), bRepaint );
    }
    plRect GetWindowRect() const
    {
        RECT R;
        ::GetWindowRect( Handle(), &R );
        return fOwnerWindow ? fOwnerWindow->ScreenToClient(R) : plRect(R);
    }
    plPoint ClientToScreen( const plPoint& inP )
    {
        POINT P;
        P.x = inP.X;
        P.y = inP.Y;
        ::ClientToScreen( Handle(), &P );
        return plPoint( P.x, P.y );
    }
    plPoint ScreenToClient( const plPoint& inP )
    {
        POINT P;
        P.x = inP.X;
        P.y = inP.Y;
        ::ScreenToClient( Handle(), &P );
        return plPoint( P.x, P.y );
    }
    plRect ClientToScreen( const plRect& inR )
    {
        return plRect( ClientToScreen(inR.Min), ClientToScreen(inR.Max) );
    }
    plRect ScreenToClient( const plRect& inR )
    {
        return plRect( ScreenToClient(inR.Min), ScreenToClient(inR.Max) );
    }
    plPoint GetCursorPos()
    {
        plPoint mouse;
        ::GetCursorPos( mouse );
        return ScreenToClient( mouse );
    }
    void Show( bool show = true )
    {
        ShowWindow( Handle(), show ? SW_SHOW : SW_HIDE );
    }
    void ShowHow( int how )
    {
        ShowWindow( Handle(), how );
    }
    void Hide()
    {
        Show(false);
    }
    bool IsVisible()
    {
        return ::IsWindowVisible(*this)?true:false;
    }

    virtual void DoDestroy()
    {
        if( Handle() )
            DestroyWindow( *this );
        std::vector<plWindow*>::iterator it = std::find(_Windows.begin(),_Windows.end(),this);
        if (it!=_Windows.end())
            _Windows.erase(it);
    }
    virtual void GetWindowClassName( wchar_t * result )=0;
    virtual LONG WndProc( unsigned int message, unsigned int wParam, LONG lParam )
    {
        try
        {
            if( message==WM_DESTROY )
            {
                OnDestroy();
            }
            else if( message==WM_DRAWITEM )
            {
                DRAWITEMSTRUCT * Info = (DRAWITEMSTRUCT*)lParam;
                for( int i=0; i<fControls.size(); i++ )
                    if( ((plWindow*)fControls[i])->Handle()==Info->hwndItem )
                        {((plWindow*)fControls[i])->OnDrawItem(Info); break;}
                return 1;
            }
            else if( message==WM_MEASUREITEM )
            {
                MEASUREITEMSTRUCT * Info = (MEASUREITEMSTRUCT*)lParam;
                for( int i=0; i<fControls.size(); i++ )
                    if( ((plWindow*)fControls[i])->fControlID==Info->CtlID )
                        {((plWindow*)fControls[i])->OnMeasureItem(Info); break;}
                return 1;
            }
            else if ( message==WM_NOTIFY )
            {
                OnNotify((int)wParam,(LPNMHDR)lParam);
            }
            else if( message==WM_CLOSE )
            {
                OnClose();
            }
            else if( message==WM_CHAR )
            {
                if (!OnChar( wParam )) // give the control a chance to filter input
                    return FALSE;
            }
            else if( message==WM_KEYDOWN )
            {
                OnKeyDown( wParam );
            }
            else if( message==WM_KEYUP )
            {
                OnKeyUp( wParam );
            }
            else if( message==WM_PAINT )
            {
                OnPaint();
            }
            else if( message==WM_CREATE )
            {
                OnCreate();
            }
            else if( message==WM_TIMER )
            {
                OnTimer( (int)wParam );
            }
            else if( message==WM_INITDIALOG )
            {
                OnInitDialog();
            }
            else if( message==WM_SETFOCUS )
            {
                OnSetFocus( (HWND)wParam );
            }
            else if( message==WM_ACTIVATE )
            {
                OnActivate( LOWORD(wParam)!=0 );
            }
            else if( message==WM_KILLFOCUS )
            {
                OnKillFocus( (HWND)wParam );
            }
            else if( message==WM_SIZE )
            {
                OnSize( wParam, LOWORD(lParam), HIWORD(lParam) );
            }
            else if( message==WM_PASTE )
            {
                OnPaste();
            }
            else if( message==WM_SHOWWINDOW )
            {
                OnShowWindow( wParam?true:false );
            }
            else if( message==WM_COPYDATA )
            {
                OnCopyData( (HWND)wParam, (COPYDATASTRUCT*)lParam );
            }
            else if( message==WM_CAPTURECHANGED )
            {
                OnReleaseCapture();
            }
            else if( message==WM_MDIACTIVATE )
            {
                OnMdiActivate( (HWND)lParam==Handle());
            }
            else if( message==WM_MOUSEMOVE )
            {
                OnMouseMove( wParam, plPoint(LOWORD(lParam), HIWORD(lParam)) );
            }
            else if( message==WM_LBUTTONDOWN )
            {
                OnLeftButtonDown();
            }
            else if( message==WM_RBUTTONDOWN )
            {
                OnRightButtonDown();
            }
            else if( message==WM_LBUTTONUP )
            {
                OnLeftButtonUp();
            }
            else if( message==WM_RBUTTONUP )
            {
                OnRightButtonUp();
            }
            else if( message==WM_CUT )
            {
                OnCut();
            }
            else if( message==WM_COPY )
            {
                OnCopy();
            }
            else if( message==WM_UNDO )
            {
                OnUndo();
            }
            else if( message==WM_SETCURSOR )
            {
                if( OnSetCursor() )
                    return 1;
            }
            else if( message==WM_COMMAND || message==WM_HSCROLL || message==WM_VSCROLL )
            {
                for( int i=0; i<fControls.size(); i++ )
                    if
                    (   (HWND)lParam==((plWindow*)fControls[i])->Handle()
                    &&  ((plWindow*)fControls[i])->InterceptControlCommand(message,wParam,lParam) )
                        return 1;
                OnCommand( wParam );
            }
            else if ( message==WM_SYSCOMMAND )
            {
                OnSysCommand( wParam );
            }
            return CallDefaultProc( message, wParam, lParam );
        }
        catch( const char * e )
        {
            hsStatusMessage( e );
            hsStatusMessage("\n");
            return 0;
        }
    }
    virtual int CallDefaultProc( unsigned int message, unsigned int wParam, LONG lParam )
    {
        if( fMdiChild )
            return DefMDIChildProc( Handle(), message, wParam, lParam );
        else
            return DefWindowProc( Handle(), message, wParam, lParam );
    }
    virtual bool InterceptControlCommand( unsigned int message, unsigned int wParam, LONG lParam )
    {
        return 0;
    }
    virtual std::wstring GetText() const
    {
        CHECK(Handle());
        int length = GetLength();
        std::wstring result;
        if (length==0)
            return result;
        result.resize(length);
        SendMessage( *this, WM_GETTEXT, length+1, (LPARAM)result.data() );
        return result;
    }
    virtual void SetText( const wchar_t * text )
    {
        CHECK(Handle());
        SendMessage( *this, WM_SETTEXT, 0, (LPARAM)text );
    }
    virtual void SetTextF( const wchar_t * fmt, ... )
    {
        va_list args;
        va_start( args, fmt );
        SetTextV( fmt, args );
        va_end( args );
    }
    virtual void SetTextV( const wchar_t * fmt, va_list args )
    {
        std::wstring s;
        xtl::formatv( s, fmt, args );
        SetText( s.c_str() );
    }
    virtual void SetEnabled(bool enabled)
    {
        CHECK(Handle());
        EnableWindow(*this,enabled);
    }
    virtual bool IsEnabled()
    {
        return IsWindowEnabled(*this)?true:false;
    }
    virtual int GetLength() const
    {
        CHECK(Handle());
        return SendMessage( *this, WM_GETTEXTLENGTH, 0, 0 );
    }
    virtual void SetFocus()
    {
        ::SetFocus(*this);
    }
    virtual void Activate()
    {
        ::SetActiveWindow(*this);
    }

    // plWindow notifications.
    virtual void OnNotify( int idCtrl, LPNMHDR pnmh )
    {}
    virtual void OnCopyData( HWND hWndSender, COPYDATASTRUCT * CD )
    {}
    virtual void OnSetFocus( HWND hWndLosingFocus )
    {}
    virtual void OnKillFocus( HWND hWndGainingFocus )
    {}
    virtual void OnSize( DWORD flags, int newX, int newY )
    {}
    virtual void OnCommand( int command )
    {}
    virtual void OnSysCommand( int command )
    {}
    virtual void OnActivate( bool active )
    {}
    virtual LONG OnChar( char ch ) // Return TRUE if you want to let the default handler grab it, FALSE if you don't
    {return TRUE;}
    virtual void OnKeyDown( UInt16 ch )
    {}
    virtual void OnKeyUp( UInt16 ch )
    {}
    virtual void OnCut()
    {}
    virtual void OnCopy()
    {}
    virtual void OnPaste()
    {}
    virtual void OnShowWindow( bool bShow )
    {}
    virtual void OnUndo()
    {}
    virtual void OnPaint()
    {}
    virtual void OnCreate()
    {}
    virtual void OnDrawItem( DRAWITEMSTRUCT * info )
    {}
    virtual void OnMeasureItem( MEASUREITEMSTRUCT * info )
    {}
    virtual void OnInitDialog()
    {}
    virtual void OnMouseEnter()
    {}
    virtual void OnMouseLeave()
    {}
    virtual void OnMouseHover()
    {}
    virtual void OnTimer( int timer )
    {}
    virtual void OnReleaseCapture()
    {}
    virtual void OnMdiActivate( bool active )
    {}
    virtual void OnMouseMove( DWORD flags, plPoint location )
    {}
    virtual void OnLeftButtonDown()
    {}
    virtual void OnRightButtonDown()
    {}
    virtual void OnLeftButtonUp()
    {}
    virtual void OnRightButtonUp()
    {}
    virtual int OnSetCursor()
    {
        return 0;
    }
    virtual void OnClose()
    {
        DestroyWindow( *this );
    }
    virtual void OnDestroy()
    {
        CHECK(Handle());
        std::vector<plWindow*>::iterator it = std::find(_Windows.begin(),_Windows.end(),this);
        if (it!=_Windows.end())
            _Windows.erase(it);
        Handle() = nil;
    }

    // plWindow functions.
    void MaybeDestroy()
    {
        if( !fDestroyed )
        {
            fDestroyed=1;
            DoDestroy();
        }
    }
    void _CloseWindow()
    {
        CHECK(Handle());
        DestroyWindow( *this );
    }
    operator HWND() const
    {
        return Handle();
    }
    void SetFont( HFONT hFont )
    {
        SendMessage( *this, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(0,0) );
    }
    void SetSmallIcon( HICON hIcon )
    {
        SendMessage( *this, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
    }
    void SetBigIcon( HICON hIcon )
    {
        SendMessage( *this, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
    }
    void PerformCreateWindowEx(
        DWORD dwExStyle,
        LPCTSTR lpWindowName,
        DWORD dwStyle,
        int x, int y,
        int nWidth, int nHeight,
        HWND hWndParent,
        HMENU hMenu,
        HINSTANCE hInstance)
    {
        CHECK(Handle()==nil);
        _Windows.push_back( this );

        wchar_t className[256];
        GetWindowClassName( className );
#ifdef UNICODE
        HWND hWndCreated = CreateWindowEx(
            dwExStyle,
            className,
            lpWindowName,
            dwStyle,x,y,
            nWidth,nHeight,
            hWndParent,hMenu,
            plWndCtrls::Instance(),
            this);
#else
        char *cClassName = hsWStringToString(className);
        HWND hWndCreated = CreateWindowEx(
            dwExStyle,
            cClassName,
            lpWindowName,
            dwStyle,x,y,
            nWidth,nHeight,
            hWndParent,hMenu,
            plWndCtrls::Instance(),
            this);
        delete [] cClassName;
#endif

/*
#define SAFE(s)     ((s)?s:"null")

        std::strstream str;
        str
            << "vars: " << std::endl
            << dwExStyle << std::endl
            << SAFE(className) << std::endl
            << SAFE(lpWindowName) << std::endl
            << dwStyle << std::endl
            << x << std::endl
            << y << std::endl
            << nWidth << std::endl
            << nHeight << std::endl
            << hWndParent << std::endl
            << hMenu  << std::endl
            << plWndCtrls::Instance() << std::endl
            << '\0';
        MessageBox(nil,str.str(),"",MB_OK);
        str.freeze(false);
*/

        if( !hWndCreated )
            hsStatusMessage( "CreateWindowEx failed" );
        CHECK(hWndCreated);
        CHECK(hWndCreated==Handle());
    }
    void SetRedraw( bool redraw )
    {
        SendMessage( *this, WM_SETREDRAW, redraw, 0 );
    }

    // plConfigValueBase
    std::string IGetValue() const
    {
        std::string sText = "";
        char *temp = hsWStringToString(GetText().c_str());
        sText = temp;
        delete [] temp;
        return sText;
    }
    void ISetValue(const char * value)
    {
        wchar_t *wValue = hsStringToWString(value);
        SetText(wValue);
        delete [] wValue;
    }
    virtual void SetEdited(bool value)
    {
        fEdited = value;
    }
    virtual bool Edited() const
    {
        return fEdited;
    }
};





#endif plWindow_h_inc