/*==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==*/
#include "HeadSpin.h"
#include "plAgeDescInterface.h"
#include "max.h"
#include "resource.h"
#include "../plFile/hsFiles.h"
#include "../plAgeDescription/plAgeDescription.h"
#include "plMaxCFGFile.h"
#include "hsStream.h"
#include "hsUtils.h"
#include "../../AssetMan/PublicInterface/MaxAssInterface.h"
#include "plMaxAccelerators.h"

#include <string>
using std::string;

extern HINSTANCE hInstance;

//// Tree Data Wrapper Class //////////////////////////////////////////////////

class plAgeFile
{
protected:
    void IGetAgeName(const char* path)
    {
        char name[_MAX_FNAME];
        _splitpath(path, nil, nil, name, nil);
        fAgeName = name;
    }

public: 
    jvUniqueId fAssetID;
    string  fPath;
    string  fAgeName;

    enum Types
    {
        kAssetFile,
        kLocalFile
    };
    Types fType;

    plAgeFile(Types type) : fType(type), fPath(nil) { }
    plAgeFile(Types type, const char *path) : fType(type)
    {
        fPath = path;
        IGetAgeName(path);
    }
    plAgeFile(Types type, const char *path, jvUniqueId& id) : fType(type), fAssetID(id)
    {
        fPath = path;
        IGetAgeName(path);
    }
};

//// Static Tree Helpers //////////////////////////////////////////////////////

static HTREEITEM    SAddTreeItem( HWND hTree, HTREEITEM hParent, const char *label, int userData );
static int  SGetTreeData( HWND tree, HTREEITEM item );

static void     RemovePageItem( HWND listBox, int item )
{
    plAgePage *page = (plAgePage *)ListBox_GetItemData( listBox, item );
    delete page;
    ListBox_DeleteString( listBox, item );
}

//// Dummy Dialog Proc ////////////////////////////////////////////////////////

BOOL CALLBACK DumbDialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
        case WM_COMMAND:
            EndDialog( hDlg, LOWORD( wParam ) );
            return TRUE;
    }
    return FALSE;
}


//// Constructor/Destructor ///////////////////////////////////////////////////

plAgeDescInterface::plAgeDescInterface() : fhDlg(nil), fDirty(false), fSpin(nil), fCurAge(-1)
{
    fCurrAgeCheckedOut = false;
    fBoldFont = nil;
    fAssetManIface = nil;

    // Make sure the date/time picker controls we need are initialized
    INITCOMMONCONTROLSEX icc;
    icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
    icc.dwICC = ICC_DATE_CLASSES;
    InitCommonControlsEx(&icc);
}

plAgeDescInterface::~plAgeDescInterface()
{
    IClearAgeFiles(fAgeFiles);

    DeleteObject( fBoldFont );
    DeleteObject( fHiliteBrush );
    fBoldFont = nil;

    delete fAssetManIface;
    fAssetManIface = nil;
}

plAgeDescInterface& plAgeDescInterface::Instance()
{
    static plAgeDescInterface theInstance;
    return theInstance;
}

void plAgeDescInterface::Open()
{
    if (!fhDlg)
    {
        CreateDialog(hInstance,
                    MAKEINTRESOURCE(IDD_AGE_DESC),
                    GetCOREInterface()->GetMAXHWnd(),
                    ForwardDlgProc);

        GetCOREInterface()->RegisterDlgWnd(fhDlg);
        ShowWindow(fhDlg, SW_SHOW);
    }
}

BOOL CALLBACK plAgeDescInterface::ForwardDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    return Instance().DlgProc(hDlg, msg, wParam, lParam);
}

BOOL plAgeDescInterface::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        fhDlg = hDlg;

        if( fAssetManIface == nil )
            fAssetManIface = TRACKED_NEW MaxAssBranchAccess();

        // Make our bold font by getting the normal font and bolding
        if( fBoldFont == nil )
        {
            HFONT origFont = (HFONT)SendMessage( hDlg, WM_GETFONT, 0, 0 );
            LOGFONT origInfo, newInfo;
            GetObject( origFont, sizeof( origInfo ), &origInfo );
            memcpy( &newInfo, &origInfo, sizeof( newInfo ) );
            newInfo.lfWeight = FW_BOLD;

            fBoldFont = CreateFontIndirect( &newInfo );
        }

        if( fHiliteBrush == nil )
            fHiliteBrush = CreateSolidBrush( RGB( 255, 0, 0 ) );

        IInitControls();
        IFillAgeTree();
        return TRUE;

    case WM_DESTROY:
        delete fAssetManIface;
        fAssetManIface = nil;
        return TRUE;

    // Day length spinner changed
    case CC_SPINNER_CHANGE:
        if (LOWORD(wParam) == IDC_DAYLEN_SPINNER ||
            LOWORD(wParam) == IDC_CAP_SPINNER ||
            LOWORD(wParam) == IDC_SEQPREFIX_SPIN )
        {
            fDirty = true;
            return TRUE;
        }
        break;

    case WM_CLOSE:
        ::SendMessage( fhDlg, WM_COMMAND, IDOK, 0 );
        return true;

    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDOK:
        case IDCANCEL:
            if( IMakeSureCheckedIn() )
            {
                IUpdateCurAge();
                DestroyWindow(fhDlg);
                fhDlg = nil;
                fDirty = false;
                fCurAge = -1;
                fSpin = nil;
            }
            return TRUE;

//      case IDC_AGE_LIST:
//          if (HIWORD(wParam) == LBN_SELCHANGE)
//          {
//              IUpdateCurAge();
//              return TRUE;
//          }
//          break;
        
        case IDC_AGE_CHECKOUT:
            ICheckOutCurrentAge();
            return TRUE;

        case IDC_AGE_CHECKIN:
            ICheckInCurrentAge();
            return TRUE;

        case IDC_AGE_UNDOCHECKOUT:
            IUndoCheckOutCurrentAge();
            return TRUE;

        case IDC_AGE_NEW:
            if (HIWORD(wParam) == BN_CLICKED)
            {
                INewAge();
                return TRUE;
            }
            break;

        case IDC_PAGE_NEW:
            if (HIWORD(wParam) == BN_CLICKED)
            {
                INewPage();
                return TRUE;
            }
            break;

        case IDC_PAGE_DEL:
            if (HIWORD(wParam) == BN_CLICKED)
            {
                HWND hPage = GetDlgItem(hDlg, IDC_PAGE_LIST);
                int sel = ListBox_GetCurSel(hPage);
                if (sel != LB_ERR)
                {
                    RemovePageItem( hPage, sel );
                    fDirty = true;
                }
                return TRUE;
            }
            break;

        case IDC_PAGE_LIST:
            if( HIWORD( wParam ) == LBN_SELCHANGE )
            {
                // Sel change
                HWND list = GetDlgItem( hDlg, IDC_PAGE_LIST );
                int sel = ListBox_GetCurSel( list );
                if( sel != LB_ERR )
                {
                    IEnablePageControls(true);

                    plAgePage *page = (plAgePage *)ListBox_GetItemData( list, sel );
                    CheckDlgButton( hDlg, IDC_ADM_DONTLOAD, ( page->GetFlags() & plAgePage::kPreventAutoLoad ) ? TRUE : FALSE );
                    CheckDlgButton( hDlg, IDC_ADM_LOADSDL, ( page->GetFlags() & plAgePage::kLoadIfSDLPresent ) ? TRUE : FALSE );
                    CheckDlgButton( hDlg, IDC_ADM_LOCAL_ONLY, ( page->GetFlags() & plAgePage::kIsLocalOnly ) ? TRUE : FALSE );
                    CheckDlgButton( hDlg, IDC_ADM_VOLATILE, ( page->GetFlags() & plAgePage::kIsVolatile ) ? TRUE : FALSE );
                }
                else
                    IEnablePageControls(false);
            }
            break;

        case IDC_ADM_DONTLOAD:
        case IDC_ADM_LOADSDL:
        case IDC_ADM_LOCAL_ONLY:
        case IDC_ADM_VOLATILE:
            ICheckedPageFlag(LOWORD(wParam));
            break;

        case IDC_EDITREG:
            // Ask the user to make sure they really want to do this
            if( GetAsyncKeyState( VK_SHIFT ) & (~1) )
            {
                if( MessageBox( hDlg, "Are you sure you wish to reassign the sequence prefix for this age?", "WARNING", MB_YESNO | MB_ICONEXCLAMATION ) == IDYES )
                {
                    Int32 prefix = (Int32)IGetNextFreeSequencePrefix( IsDlgButtonChecked( hDlg, IDC_RSVDCHECK ) );
                    fSeqPrefixSpin->SetValue( ( prefix >= 0 ) ? prefix : -prefix, false );
                    fDirty = true;
                }
            }
            else
            {
                if( MessageBox( hDlg, "Editing the registry data for an age can be extremely dangerous and "
                                    "can cause instabilities and crashes, particularly with multiplayer. "
                                    "Are you sure you want to do this?", "WARNING", MB_YESNO | MB_ICONEXCLAMATION ) == IDYES )
                {
                    // Enable the controls
                    EnableWindow( GetDlgItem( hDlg, IDC_RSVDCHECK ), TRUE );
                    EnableWindow( GetDlgItem( hDlg, IDC_SEQPREFIX_EDIT ), TRUE );
                    EnableWindow( GetDlgItem( hDlg, IDC_SEQPREFIX_SPIN ), TRUE );
                }
            }
            return TRUE;

        case IDC_RSVDCHECK:
            fDirty = true;
            return FALSE;   // Still process as normal

        case IDC_BRANCHCOMBO:
            if( HIWORD( wParam ) == CBN_SELCHANGE )
            {
                int idx = SendDlgItemMessage( hDlg, IDC_BRANCHCOMBO, CB_GETCURSEL, 0, 0 );
                if( idx != CB_ERR )
                {
                    int id = SendDlgItemMessage( hDlg, IDC_BRANCHCOMBO, CB_GETITEMDATA, idx, 0 );

                    fAssetManIface->SetCurrBranch( id );
                    IFillAgeTree();
                }
            }
            return TRUE;
        }
        break;

    case WM_PAINT:
        PAINTSTRUCT paintInfo;

        BeginPaint( hDlg, &paintInfo );

        if( fCurrAgeCheckedOut )
        {
            RECT    r;
            HWND    dummy = GetDlgItem( hDlg, IDC_AGEDESC );
            GetClientRect( dummy, &r );
            MapWindowPoints( dummy, hDlg, (POINT *)&r, 2 );

            for( int i = 0; i < 3; i++ )
            {
                InflateRect( &r, -1, -1 );
                FrameRect( paintInfo.hdc, &r, fHiliteBrush );
            }
        }

        EndPaint( hDlg, &paintInfo );
        return TRUE;

    case WM_NOTIFY:
        {
            NMHDR *hdr = (NMHDR*)lParam;

            // Message from the start date/time controls
            if (hdr->idFrom == IDC_DATE || hdr->idFrom == IDC_TIME)
            {
                if (hdr->code == NM_KILLFOCUS)
                {
                    plMaxAccelerators::Enable();
                    return TRUE;
                }
                else if (hdr->code == NM_SETFOCUS)
                {
                    plMaxAccelerators::Disable();
                    return TRUE;
                }
                // Time or date changed, set dirty
                else if (hdr->code == DTN_DATETIMECHANGE)
                {
                    fDirty = true;
                    return TRUE;
                }   
            }
            else if( hdr->idFrom == IDC_AGE_LIST )
            {
                if( hdr->code == NM_CUSTOMDRAW )
                {
                    // Custom draw notifications for our treeView control
                    LPNMTVCUSTOMDRAW    treeNotify = (LPNMTVCUSTOMDRAW)lParam;

                    if( treeNotify->nmcd.dwDrawStage == CDDS_PREPAINT )
                    {
                        // Sent at the start of redraw, lets us request more specific notifys
                        SetWindowLong( hDlg, DWL_MSGRESULT, CDRF_NOTIFYITEMDRAW );
                        return TRUE;
                    }
                    else if( treeNotify->nmcd.dwDrawStage == CDDS_ITEMPREPAINT )
                    {
                        // Prepaint on an item. We get to change item font and color here
                        int idx = SGetTreeData( hdr->hwndFrom, (HTREEITEM)treeNotify->nmcd.dwItemSpec );
/*                      if( item == nil || item->fType != plAgeFile::kBranch )
                        {
                            // Default drawing, with default font and such
                            SetWindowLong( hDlg, DWL_MSGRESULT, CDRF_DODEFAULT );
                            return TRUE;
                        }       
*/
                        // Color change (only if the item isn't selected)
                        if( (HTREEITEM)treeNotify->nmcd.dwItemSpec != TreeView_GetSelection( hdr->hwndFrom ) )
                        {
                            treeNotify->clrText = GetColorManager()->GetColor( kText );
                            treeNotify->clrTextBk = GetColorManager()->GetColor( kWindow );
                        }

                        if (idx == -1)
                        {
                            // Set a bold font for the branch headers
                            if( fBoldFont != nil )
                                SelectObject( treeNotify->nmcd.hdc, fBoldFont );
                        }

                        // Let Windows know we changed the font
                        SetWindowLong( hDlg, DWL_MSGRESULT, CDRF_NEWFONT );
                        return TRUE;
                    }
                    else
                        // Let the default handle it
                        return FALSE;
                }
                else if( hdr->code == TVN_SELCHANGING )
                {
                    SetWindowLong( hDlg, DWL_MSGRESULT, !IMakeSureCheckedIn() );
                    return TRUE;
                }
                else if( hdr->code == TVN_SELCHANGED )
                {
                    // Update the viewing age
                    IUpdateCurAge();
                    return TRUE;
                }
            }
        }
        break;
    }

    return FALSE;
}

void plAgeDescInterface::ICheckedPageFlag(int ctrlID)
{
    HWND hList = GetDlgItem(fhDlg, IDC_PAGE_LIST);
    int sel = ListBox_GetCurSel(hList);
    if (sel == LB_ERR)
        return;

    plAgePage* page = (plAgePage*)ListBox_GetItemData(hList, sel);
    bool isChecked = (IsDlgButtonChecked(fhDlg, ctrlID) == BST_CHECKED);

    if (ctrlID == IDC_ADM_DONTLOAD)
    {
        if (isChecked)
        {
            page->SetFlags(plAgePage::kPreventAutoLoad, true);

            // Doesn't make sense to have loadWithSDL checked too
            CheckDlgButton(fhDlg, IDC_ADM_LOADSDL, FALSE);
            page->SetFlags(plAgePage::kLoadIfSDLPresent, false);
        }
        else
            page->SetFlags(plAgePage::kPreventAutoLoad, false);
    }
    else if (ctrlID == IDC_ADM_LOADSDL)
    {
        if (isChecked)
        {
            page->SetFlags(plAgePage::kLoadIfSDLPresent, true);

            // Doesn't make sense to have dontLoad checked too
            CheckDlgButton(fhDlg, IDC_ADM_DONTLOAD, FALSE);
            page->SetFlags(plAgePage::kPreventAutoLoad, false);
        }
        else
            page->SetFlags(plAgePage::kLoadIfSDLPresent, false);
    }
    else if (ctrlID == IDC_ADM_LOCAL_ONLY)
    {
        page->SetFlags(plAgePage::kIsLocalOnly, isChecked);
    }
    else if (ctrlID == IDC_ADM_VOLATILE)
    {
        page->SetFlags(plAgePage::kIsVolatile, isChecked);
    }
}

void    plAgeDescInterface::ICheckOutCurrentAge( void )
{
    hsAssert( !fCurrAgeCheckedOut, "Trying to re-check out an age!" );

    plAgeFile *currAge = IGetCurrentAge();
    if( currAge == nil )
    {
        hsAssert( false, "How are you checking out an age if none is selected?" );
        return;
    }

    if( currAge->fType != plAgeFile::kAssetFile )
        return;

    // Check it out from AssetMan
    bool checkOutSuccess = (*fAssetManIface)->CheckOutAsset( currAge->fAssetID, fCheckedOutPath, sizeof( fCheckedOutPath ) );
    if( !checkOutSuccess )
    {
        hsMessageBox( "Unable to check out age file from AssetMan. Most likely somebody already has it checked out.", "Error", hsMessageBoxNormal );
        return;
    }
    fCurrAgeCheckedOut = true;

    // Make sure we loaded the latest version
    ILoadAge( fCheckedOutPath, true );

    IInvalidateCheckOutIndicator();
    IEnableControls( true );
}

void    plAgeDescInterface::ICheckInCurrentAge( void )
{
    hsAssert( fCurrAgeCheckedOut, "Trying to check in an age when none is checked out!" );

    plAgeFile *currAge = IGetCurrentAge();
    if( currAge == nil )
    {
        hsAssert( false, "How are you checking in an age if none is selected?" );
        return;
    }

    // Save the sucker
    ISaveCurAge( fCheckedOutPath );

    // Check the age file back in to AssetMan
    (*fAssetManIface)->CheckInAsset( currAge->fAssetID, fCheckedOutPath, "" );
    fCurrAgeCheckedOut = false;

    IInvalidateCheckOutIndicator();
    IEnableControls( true );
}

void    plAgeDescInterface::IUndoCheckOutCurrentAge( void )
{
    hsAssert( fCurrAgeCheckedOut, "Trying to undo check out an age when none is checked out!" );

    plAgeFile *currAge = IGetCurrentAge();
    if( currAge == nil )
    {
        hsAssert( false, "How are you undoing a checkout if no age is selected?" );
        return;
    }

    // Check the age file back in to AssetMan
    (*fAssetManIface)->UndoCheckOutAsset(currAge->fAssetID);
    fCurrAgeCheckedOut = false;

    // Reload the non-saved version
    ILoadAge( fCheckedOutPath );

    IInvalidateCheckOutIndicator();
    IEnableControls( true );
}

void    plAgeDescInterface::IInvalidateCheckOutIndicator( void )
{
    RECT    r;
    HWND    dummy = GetDlgItem( fhDlg, IDC_AGEDESC );
    GetClientRect( dummy, &r );
    MapWindowPoints( dummy, fhDlg, (POINT *)&r, 2 );

    RedrawWindow( fhDlg, &r, nil, RDW_INVALIDATE | RDW_ERASE );
}

hsBool  plAgeDescInterface::IMakeSureCheckedIn( void )
{
    int result;
    plAgeFile* currAge = IGetCurrentAge();
    if (!currAge)
        return true;

    if ( currAge->fType == plAgeFile::kAssetFile && fCurrAgeCheckedOut )
    {
        // We're switching away from an age we have checked out--ask what they want to do
        result = DialogBox( hInstance, MAKEINTRESOURCE( IDD_AGE_CHECKIN ),
                                GetCOREInterface()->GetMAXHWnd(), DumbDialogProc );
        if( result == IDCANCEL )
        {
            // Got cancelled
            return false;
        }
        else if( result == IDYES )
        {
            ICheckInCurrentAge();
        }
        else
        {
            IUndoCheckOutCurrentAge();
        }
    }
    else if( currAge->fType == plAgeFile::kLocalFile && fDirty )
    {
        // Ask if we want to save changes
        result = DialogBox( hInstance, MAKEINTRESOURCE( IDD_AGE_SAVEYESNO ),
                                GetCOREInterface()->GetMAXHWnd(), DumbDialogProc );
        if( result == IDCANCEL )
        {
            // Got cancelled
            return false;
        }
        else if( result == IDYES )
        {
            ISaveCurAge( currAge->fPath.c_str() );
        }
        else
        {
            // Reload the non-saved version
            ILoadAge( currAge->fPath.c_str() );
        }
        IEnableControls( true );
    }
    return true;
}

void    plAgeDescInterface::IUpdateCurAge( void )
{
    // Get the current age selection
    plAgeFile   *currAge = IGetCurrentAge();

    if (currAge == nil)
    {
        ISetControlDefaults();
        IEnableControls( false );
        return;
    }

    IEnableControls( true );

    if( currAge->fType == plAgeFile::kAssetFile )
    {
        // Gotta get the latest version from assetMan before loading
        char                localFilename[ MAX_PATH ];
        if( !(*fAssetManIface)->GetLatestVersionFile( currAge->fAssetID, localFilename, sizeof( localFilename ) ) )
        {
            hsMessageBox( "Unable to get latest version of age asset from AssetMan. Things are about to get very funky...", "ERROR", hsMessageBoxNormal );
        }
        else
        {
            ILoadAge( localFilename );
        }
    }
    else
        // Load the local age, also check its sequence #s
        ILoadAge( currAge->fPath.c_str(), true );
}

static const int kDefaultCapacity = 10;

void plAgeDescInterface::IInitControls()
{
    // Fill the branch combo box
    SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_RESETCONTENT, 0, 0 );
    const jvTypeArray &branches = (*fAssetManIface)->GetBranches();
    int i, curr = 0;
    for( i = 0; i < branches.Size(); i++ )
    {
        int idx = SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_ADDSTRING, 0, (LPARAM)(const char *)( branches[ i ].Name ) );
        SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_SETITEMDATA, idx, (LPARAM)branches[ i ].Id );

        if( branches[ i ].Id == fAssetManIface->GetCurrBranch() )
            curr = i;
    }
    SendDlgItemMessage( fhDlg, IDC_BRANCHCOMBO, CB_SETCURSEL, curr, 0 );


    fSpin = SetupFloatSpinner(fhDlg, IDC_DAYLEN_SPINNER, IDC_DAYLEN_EDIT, 1.f, 100.f, 24.f);
    fCapSpin = SetupIntSpinner(fhDlg, IDC_CAP_SPINNER, IDC_CAP_EDIT, 1, 250, kDefaultCapacity);
    fSeqPrefixSpin = SetupIntSpinner(fhDlg, IDC_SEQPREFIX_SPIN, IDC_SEQPREFIX_EDIT, 1, 102400, 1);

    SendDlgItemMessage( fhDlg, IDC_AGELIST_STATIC, WM_SETFONT, (WPARAM)fBoldFont, MAKELPARAM( TRUE, 0 ) );
    SendDlgItemMessage( fhDlg, IDC_AGEDESC, WM_SETFONT, (WPARAM)fBoldFont, MAKELPARAM( TRUE, 0 ) );

    ISetControlDefaults();
    IEnableControls(false);
}

void plAgeDescInterface::ISetControlDefaults()
{
    HWND hDate = GetDlgItem(fhDlg, IDC_DATE);
    HWND hTime = GetDlgItem(fhDlg, IDC_TIME);

    SYSTEMTIME st = {0};
    st.wDay = 1;
    st.wMonth = 1;
    st.wYear = 2000;
    DateTime_SetSystemtime(hDate, GDT_VALID, &st);
    DateTime_SetSystemtime(hTime, GDT_VALID, &st);

    fSpin->SetValue(24.f, FALSE);
    fCapSpin->SetValue(kDefaultCapacity, FALSE);

    CheckDlgButton( fhDlg, IDC_ADM_DONTLOAD, FALSE );

    int i;
    HWND ctrl = GetDlgItem( fhDlg, IDC_PAGE_LIST );
    for( i = SendMessage( ctrl, LB_GETCOUNT, 0, 0 ) - 1; i >= 0; i-- )
        RemovePageItem( ctrl, i );

    SetDlgItemText( fhDlg, IDC_AGEDESC, "Age Description" );
}

void plAgeDescInterface::IEnableControls(bool enable)
{
    bool checkedOut = true;

    plAgeFile *currAge = IGetCurrentAge();
    if( currAge != nil && currAge->fType == plAgeFile::kAssetFile )
        checkedOut = fCurrAgeCheckedOut && enable;
    else if( currAge != nil && currAge->fType == plAgeFile::kLocalFile )
        checkedOut = enable;
    else
        checkedOut = false;

    EnableWindow(GetDlgItem(fhDlg, IDC_DATE), checkedOut );
    EnableWindow(GetDlgItem(fhDlg, IDC_TIME), checkedOut );
    EnableWindow(GetDlgItem(fhDlg, IDC_PAGE_LIST), checkedOut );
    EnableWindow(GetDlgItem(fhDlg, IDC_PAGE_NEW), checkedOut );
    EnableWindow(GetDlgItem(fhDlg, IDC_PAGE_DEL), checkedOut );
    EnableWindow(GetDlgItem(fhDlg, IDC_EDITREG), checkedOut );

    if (!enable || !checkedOut)
        IEnablePageControls(false);

    fSpin->Enable(checkedOut );
    fCapSpin->Enable(checkedOut );

    if( currAge != nil && currAge->fType == plAgeFile::kAssetFile )
    {
        EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKIN ), checkedOut );
        EnableWindow( GetDlgItem( fhDlg, IDC_AGE_UNDOCHECKOUT ), checkedOut );
        EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKOUT ), !checkedOut );
    }
    else
    {
        EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKIN ), false );
        EnableWindow( GetDlgItem( fhDlg, IDC_AGE_UNDOCHECKOUT ), false );
        EnableWindow( GetDlgItem( fhDlg, IDC_AGE_CHECKOUT ), false );
    }
}

void plAgeDescInterface::IEnablePageControls(bool enable)
{
    EnableWindow(GetDlgItem(fhDlg, IDC_ADM_DONTLOAD), enable);
    EnableWindow(GetDlgItem(fhDlg, IDC_ADM_LOADSDL), enable);
    EnableWindow(GetDlgItem(fhDlg, IDC_ADM_LOCAL_ONLY), enable);
    EnableWindow(GetDlgItem(fhDlg, IDC_ADM_VOLATILE), enable);
}

bool plAgeDescInterface::IGetLocalAgePath(char *path)
{
    // Get the path to the description folder
    const char *plasmaPath = plMaxConfig::GetClientPath();
    if (!plasmaPath)
        return false;

    strcpy(path, plasmaPath);
    strcat(path, plAgeDescription::kAgeDescPath);

    // Make sure the desc folder exists
    CreateDirectory(path, NULL);

    return true;
}

int plAgeDescInterface::IFindAge(const char* ageName, vector<plAgeFile*>& ageFiles)
{
    for (int i = 0; i < ageFiles.size(); i++)
        if (ageFiles[i]->fAgeName == ageName)
            return i;

    return -1;
}

void plAgeDescInterface::IGetAgeFiles(vector<plAgeFile*>& ageFiles)
{
    IClearAgeFiles(ageFiles);

    char agePath[MAX_PATH];

    // Make list of "local" ages. This might contain copies of those in AssetMan, so we make the
    // list first and take out the ones that are in AssetMan
    char localPath[MAX_PATH];
    if (IGetLocalAgePath(localPath))
    {
        hsFolderIterator ageFolder(localPath);
        while (ageFolder.NextFileSuffix(".age"))
        {
            ageFolder.GetPathAndName(agePath);

            plAgeFile* age = TRACKED_NEW plAgeFile(plAgeFile::kLocalFile, agePath);
            ageFiles.push_back(age);
        }
    }

    // Add AssetMan ages, if available (since we're static, go thru the main MaxAss interface)
    MaxAssInterface *assetMan = GetMaxAssInterface();
    if( assetMan!= nil )
    {
        hsTArray<jvUniqueId> doneAssets;

        jvArray<jvUniqueId>* assets = assetMan->GetAssetsByType(MaxAssInterface::kTypeAge);
        for (int i = 0; i < assets->Size(); i++)
        {
            if( doneAssets.Find( (*assets)[ i ] ) == doneAssets.kMissingIndex )
            {
                if (assetMan->GetLatestVersionFile((*assets)[i], agePath, sizeof(agePath)))
                {
                    plAgeFile* age = TRACKED_NEW plAgeFile(plAgeFile::kAssetFile, agePath, (*assets)[i]);

                    int existing = IFindAge(age->fAgeName.c_str(), ageFiles);
                    // Remove it from our "local" list if there, since it's a duplicate
                    if (existing != -1)
                    {
                        delete ageFiles[existing];
                        ageFiles[existing] = age;
                    }
                    else
                        ageFiles.push_back(age);

                    doneAssets.Append( (*assets)[ i ] );
                }
            }
        }
        assets->DeleteSelf();
    }
}

void plAgeDescInterface::IClearAgeFiles(vector<plAgeFile*>& ageFiles)
{
    for (int i = 0; i < ageFiles.size(); i++)
        delete ageFiles[i];
    ageFiles.clear();
}

void plAgeDescInterface::BuildAgeFileList( hsTArray<char *> &ageList )
{
    vector<plAgeFile*> tempAgeFiles;
    IGetAgeFiles(tempAgeFiles);

    for (int i = 0; i < tempAgeFiles.size(); i++)
    {
        ageList.Push(hsStrcpy(tempAgeFiles[i]->fPath.c_str()));
        delete tempAgeFiles[ i ];
    }
}

//// IFillAgeTree /////////////////////////////////////////////////////////////
//  Refreshes/inits the tree view of all ages we have to work with. If
//  specified, will also get the latest version of the .age files from assetMan.
void plAgeDescInterface::IFillAgeTree( void )
{
    HWND ageTree = GetDlgItem( fhDlg, IDC_AGE_LIST );

    // Clear the tree first and add our two root headers
    TreeView_DeleteAllItems(ageTree);

    if( fAssetManIface != nil )
        fAssetManBranch = SAddTreeItem(ageTree, nil, "AssetMan Ages", -1);
    else
        fAssetManBranch = nil;
    fLocalBranch = SAddTreeItem(ageTree, nil, "Local Ages", -1);

    IGetAgeFiles(fAgeFiles);

    // Add the ages to the tree
    for (int i = 0; i < fAgeFiles.size(); i++)
    {
        SAddTreeItem(ageTree,
                    (fAgeFiles[i]->fType == plAgeFile::kAssetFile) ? fAssetManBranch : fLocalBranch,
                    fAgeFiles[i]->fAgeName.c_str(),
                    i);
    }

    // Select the first age to view
    IUpdateCurAge();
}

BOOL CALLBACK NewAgeDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static char *name = nil;

    switch (msg)
    {
    case WM_INITDIALOG:
        name = (char*)lParam;
        SetWindowText(hDlg, name);
        return TRUE;

    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDOK)
        {
            if (GetDlgItemText(hDlg, IDC_AGE_NAME, name, _MAX_FNAME) > 0)
                EndDialog(hDlg, 1);
            else
                EndDialog(hDlg, 0);
            return TRUE;
        }
        else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, 0);
            return TRUE;
        }
    }

    return FALSE;
}

BOOL CALLBACK NewSeqNumberProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static char msg1[] = "This age currently does not have a sequence number assigned to it. All ages "
                         "must have a unique sequence number for multiplayer to work. Unassigned ages "
                         "will get a temporary random number at export time, but will result in undefined "
                         "(but probably bad) behavior during multiplayer games. In general, you should "
                         "always assign a sequence number to an age unless you have a very specific and "
                         "good reason not to.";
    static char msg2[] = "The ADManager can find and assign a new, unique sequence number to this age for "
                         "you. You can choose to assign a normal or a global/reserved number. Normal ages "
                         "are ones for gameplay (that you can link to, walk around in, etc.), while "
                         "global/reserved ages are typically for storing data (such as avatars, GUI dialogs, etc.)";
    char    msg3[ 512 ];


    switch (msg)
    {
    case WM_INITDIALOG:
        SetDlgItemText( hDlg, IDC_INFOMSG, msg1 );
        SetDlgItemText( hDlg, IDC_ADMMSG, msg2 );
        sprintf( msg3, "Age: %s", (char *)lParam );
        SetDlgItemText( hDlg, IDC_AGEMSG, msg3 );
        return TRUE;

    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED )
        {
            EndDialog( hDlg, LOWORD( wParam ) );
            return TRUE;
        }
    }

    return FALSE;
}

void plAgeDescInterface::INewAge()
{  
    VARIANT assetId;
    VariantInit(&assetId);

    bool makeAsset = true;
    if( hsMessageBox( "Do you wish to store your new age in AssetMan?", "Make source-controlled?", hsMessageBoxYesNo ) == hsMBoxNo )
        makeAsset = false;

    char    newAssetFilename[ MAX_PATH ];
    if (!fAssetManIface)
        makeAsset = false;

    if( !IGetLocalAgePath( newAssetFilename ) )
        return;

    char name[_MAX_FNAME];
    strcpy(name, "New Age Name");

    // Get the name of the new age from the user
    int ret = DialogBoxParam(hInstance,
               MAKEINTRESOURCE(IDD_AGE_NAME),
               GetCOREInterface()->GetMAXHWnd(),
               NewAgeDlgProc,
               (LPARAM)name);
    if (ret != 1)
        return;

    strcat(newAssetFilename, name);
    strcat(newAssetFilename, ".age");

    if( !makeAsset )
        fForceSeqNumLocal = true;
    ISetControlDefaults();
    ISaveCurAge(newAssetFilename, true);    // Check sequence # while we're at it
    fForceSeqNumLocal = false;

    if( makeAsset )
        (*fAssetManIface)->AddNewAsset(newAssetFilename);

    // Refresh the tree now
    IFillAgeTree();
}

void plAgeDescInterface::INewPage()
{
    char name[256];
    strcpy(name, "New Page Name");

    // Get the name of the new age from the user
    int ret = DialogBoxParam(hInstance,
                            MAKEINTRESOURCE(IDD_AGE_NAME),
                            GetCOREInterface()->GetMAXHWnd(),
                            NewAgeDlgProc,
                            (LPARAM)name);
    if (ret != 1)
        return;

    HWND hPages = GetDlgItem(fhDlg, IDC_PAGE_LIST);

    // Make sure this page doesn't already exist
    int count = ListBox_GetCount(hPages);
    for (int i = 0; i < count; i++)
    {
        char pageName[256];
        ListBox_GetText(hPages, i, pageName);
        if (!strcmp(pageName, name))
            return;
    }

    // Add the new page and select it
    int idx = ListBox_AddString(hPages, name);

    // Choose a new sequence suffix for it
    plAgePage *newPage = TRACKED_NEW plAgePage( name, IGetFreePageSeqSuffix( hPages ), 0 );
    ListBox_SetItemData( hPages, idx, (LPARAM)newPage );
   
    fDirty = true;
}

UInt32  plAgeDescInterface::IGetFreePageSeqSuffix( HWND pageCombo )
{
    int     i, count = ListBox_GetCount( pageCombo );
    UInt32  searchSeq = 1;

    do
    {
        for( i = 0; i < count; i++ )
        {
            plAgePage *page = (plAgePage *)ListBox_GetItemData( pageCombo, i );
            if( page != nil && page->GetSeqSuffix() == searchSeq )
            {
                searchSeq++;
                break;
            }
        }

    } while( i < count );

    return searchSeq;
}

void plAgeDescInterface::ISaveCurAge( const char *path, hsBool checkSeqNum )
{
    hsUNIXStream s;
    if( !s.Open( path, "wt" ) )
    {
        hsMessageBox("Unable to open the Age Description file for writing. Updates not saved.", "Error", hsMessageBoxNormal);
        return;
    }

    plAgeDescription aged;
    aged.SetAgeNameFromPath( path );

    // set the date and time
    HWND hDate = GetDlgItem(fhDlg, IDC_DATE);
    SYSTEMTIME dst = {0};
    DateTime_GetSystemtime(hDate, &dst);
    HWND hTime = GetDlgItem(fhDlg, IDC_TIME);
    SYSTEMTIME tst = {0};
    DateTime_GetSystemtime(hTime, &tst);
    aged.SetStart(dst.wYear,dst.wMonth,dst.wDay,tst.wHour,tst.wMinute,tst.wSecond);
    aged.SetDayLength(fSpin->GetFVal());
    aged.SetMaxCapacity(fCapSpin->GetIVal());
    if( checkSeqNum )
    {
        ICheckSequenceNumber( aged );
    }
    else if( IsDlgButtonChecked( fhDlg, IDC_RSVDCHECK ) )
    {
        // Store reserved sequence prefix
        aged.SetSequencePrefix( -fSeqPrefixSpin->GetIVal() );
    }
    else
    {
        aged.SetSequencePrefix( fSeqPrefixSpin->GetIVal() );
    }

    // gather pages
    HWND hPages = GetDlgItem(fhDlg, IDC_PAGE_LIST);
    int count = ListBox_GetCount(hPages);
    if (count != LB_ERR)
    {
        for (int i = 0; i < count; i++)
        {
            char pageName[256];
            ListBox_GetText(hPages, i, pageName);
            plAgePage *page = (plAgePage *)ListBox_GetItemData( hPages, i );
            aged.AppendPage( pageName, page->GetSeqSuffix(), page->GetFlags() );
        }
    }

    // write it all out
    aged.Write(&s);
    s.Close();
}

//// ICheckSequenceNumber /////////////////////////////////////////////////////
//  Checks to make sure the sequence prefix is valid. If not, asks to assign
//  a good one.

void    plAgeDescInterface::ICheckSequenceNumber( plAgeDescription &aged )
{
    if( aged.GetSequencePrefix() == 0 ) // Default of uninitialized
    {
        // Ask about the sequence #
        int ret = DialogBoxParam( hInstance, MAKEINTRESOURCE( IDD_AGE_SEQNUM ),
                                    GetCOREInterface()->GetMAXHWnd(),
                                        NewSeqNumberProc, (LPARAM)aged.GetAgeName() );
        if( ret == IDYES )
        {
            aged.SetSequencePrefix( IGetNextFreeSequencePrefix( false ) );
            fDirty = true;
        }
        else if( ret == IDNO )
        {
            aged.SetSequencePrefix( IGetNextFreeSequencePrefix( true ) );
            fDirty = true;
        }
    }
}

void plAgeDescInterface::ILoadAge( const char *path, hsBool checkSeqNum )
{
    ISetControlDefaults();
    
    fDirty = false;

    // create and read the age desc
    plAgeDescription aged( path );

    // Get the name of the age
    char ageName[_MAX_FNAME];
    _splitpath( path, nil, nil, ageName, nil );

    // Check the sequence prefix #
    if( checkSeqNum )
        ICheckSequenceNumber( aged );

    char str[ _MAX_FNAME + 30 ];
    sprintf( str, "Description for %s", ageName );
    SetDlgItemText( fhDlg, IDC_AGEDESC, str );

    // Set up the Dlgs
    SYSTEMTIME st;

    HWND hTime = GetDlgItem(fhDlg, IDC_TIME);
    memset(&st,0, sizeof(st));
    st.wYear = 2000;
    st.wMonth = 1;
    st.wDay = 1;
    st.wHour = aged.GetStartHour();
    st.wMinute = aged.GetStartMinute();
    st.wSecond = aged.GetStartSecond();
    DateTime_SetSystemtime(hTime, GDT_VALID, &st);

    
    HWND hDate = GetDlgItem(fhDlg, IDC_DATE);
    memset(&st,0, sizeof(st));
    st.wMonth = aged.GetStartMonth();
    st.wDay = aged.GetStartDay();
    st.wYear = aged.GetStartYear();
    DateTime_SetSystemtime(hDate, GDT_VALID, &st);

    
    fSpin->SetValue(aged.GetDayLength(), FALSE);

    int maxCap = aged.GetMaxCapacity();
    if (maxCap == -1)
    {
        maxCap = kDefaultCapacity;
        fDirty = true;
    }
    fCapSpin->SetValue(maxCap, FALSE);

    Int32 seqPrefix = aged.GetSequencePrefix();
    if( seqPrefix < 0 )
    {
        // Reserved prefix
        fSeqPrefixSpin->SetValue( (int)( -seqPrefix ), FALSE );
        CheckDlgButton( fhDlg, IDC_RSVDCHECK, BST_CHECKED );
    }
    else
    {
        fSeqPrefixSpin->SetValue( (int)seqPrefix, FALSE );
        CheckDlgButton( fhDlg, IDC_RSVDCHECK, BST_UNCHECKED );
    }

    // Disable the registry controls for now
    EnableWindow( GetDlgItem( fhDlg, IDC_RSVDCHECK ), false );
    EnableWindow( GetDlgItem( fhDlg, IDC_SEQPREFIX_EDIT ), false );
    EnableWindow( GetDlgItem( fhDlg, IDC_SEQPREFIX_SPIN ), false );

    aged.SeekFirstPage();
    plAgePage *page;

    HWND hPage = GetDlgItem(fhDlg, IDC_PAGE_LIST);
    while( ( page = aged.GetNextPage() ) != nil )
    {
        int idx = ListBox_AddString( hPage, page->GetName() );
        ListBox_SetItemData( hPage, idx, (LPARAM)new plAgePage( *page ) );
    }
}

UInt32  plAgeDescInterface::IGetNextFreeSequencePrefix( hsBool getReservedPrefix )
{
    Int32               searchSeq = getReservedPrefix ? -1 : 1;
    hsTArray<char *>    ageList;
    int                 i;

    hsTArray<plAgeDescription>  ages;


    if( fForceSeqNumLocal )
        searchSeq = getReservedPrefix ? -1024 : 1024;

    IGetAgeFiles(fAgeFiles);

    ages.SetCount( fAgeFiles.size() );
    for( i = 0; i < fAgeFiles.size(); i++ )
    {
        hsUNIXStream stream;
        if( stream.Open( fAgeFiles[ i ]->fPath.c_str(), "rt" ) )
        {
            ages[ i ].Read( &stream );
            stream.Close();
        }
    }

    do
    {
        if( getReservedPrefix )
        {
            for( i = 0; i < ages.GetCount(); i++ )
            {
                if( ages[ i ].GetSequencePrefix() == searchSeq )
                {
                    searchSeq--;
                    break;
                }
            }
        }
        else
        {
            for( i = 0; i < ages.GetCount(); i++ )
            {
                if( ages[ i ].GetSequencePrefix() == searchSeq )
                {
                    searchSeq++;
                    break;
                }
            }
        }
    } while( i < ages.GetCount() );

    return searchSeq;
}

plAgeFile* plAgeDescInterface::IGetCurrentAge( void )
{
    HWND    ageTree = GetDlgItem( fhDlg, IDC_AGE_LIST );
    fCurrAgeItem = TreeView_GetSelection( ageTree );
    if( fCurrAgeItem == nil )
        return nil;

    int idx = SGetTreeData( ageTree, fCurrAgeItem );
    if (idx == -1)
        return nil;

    return fAgeFiles[idx];
}

//// SAddTreeItem /////////////////////////////////////////////////////////////
//  Static helper function for adding an item to a treeView

static HTREEITEM SAddTreeItem( HWND hTree, HTREEITEM hParent, const char *label, int userData )
{
    TVITEM tvi = {0};
    tvi.mask       = TVIF_TEXT | TVIF_PARAM;
    tvi.pszText    = (char *)label;
    tvi.cchTextMax = strlen( label );  
    tvi.lParam     = (LPARAM)userData;
    if( userData == -1 )
    {
        tvi.mask |= TVIF_STATE;
        tvi.state = tvi.stateMask = TVIS_BOLD | TVIS_EXPANDED;
    }

    TVINSERTSTRUCT tvins = {0};
    tvins.item         = tvi;
    tvins.hParent      = hParent;
    tvins.hInsertAfter = TVI_LAST;

    return TreeView_InsertItem( hTree, &tvins );
}

//// SGetTreeData /////////////////////////////////////////////////////////////
//  Gets the tree data for the given item

int SGetTreeData( HWND tree, HTREEITEM item )
{
    TVITEM  itemInfo;
    itemInfo.mask = TVIF_PARAM | TVIF_HANDLE;
    itemInfo.hItem = item;
    TreeView_GetItem( tree, &itemInfo );
    return itemInfo.lParam;
}