// Minecraft.cpp : Defines the entry point for the application.
//

#include "../../Minecraft.World/Platform/stdafx.h"
#include "XUI_SettingsOptions.h"

int CScene_SettingsOptions::m_iDifficultySettingA[4] = {
    IDS_DIFFICULTY_PEACEFUL, IDS_DIFFICULTY_EASY, IDS_DIFFICULTY_NORMAL,
    IDS_DIFFICULTY_HARD};

int CScene_SettingsOptions::m_iDifficultyTitleSettingA[4] = {
    IDS_DIFFICULTY_TITLE_PEACEFUL, IDS_DIFFICULTY_TITLE_EASY,
    IDS_DIFFICULTY_TITLE_NORMAL, IDS_DIFFICULTY_TITLE_HARD};

//----------------------------------------------------------------------------------
// Performs initialization tasks - retrieves controls.
//----------------------------------------------------------------------------------
HRESULT CScene_SettingsOptions::OnInit(XUIMessageInit* pInitData,
                                       BOOL& bHandled) {
    WCHAR TempString[256];
    m_iPad = *(int*)pInitData->pvInitData;
    // if we're not in the game, we need to use basescene 0
    bool bNotInGame = (Minecraft::GetInstance()->level == NULL);
    bool bPrimaryPlayer = ProfileManager.GetPrimaryPad() == m_iPad;

    MapChildControls();

    XuiControlSetText(m_ViewBob, app.GetString(IDS_VIEW_BOBBING));
    XuiControlSetText(m_Hints, app.GetString(IDS_HINTS));
    XuiControlSetText(m_Tooltips, app.GetString(IDS_IN_GAME_TOOLTIPS));
    XuiControlSetText(m_InGameGamertags, app.GetString(IDS_IN_GAME_GAMERTAGS));
    XuiControlSetText(m_MashUpWorlds, app.GetString(IDS_UNHIDE_MASHUP_WORLDS));

    // check if we should display the mash-up option
    if (bNotInGame && app.GetMashupPackWorlds(m_iPad) != 0xFFFFFFFF) {
        // the mash-up option is needed
        m_bMashUpWorldsUnhideOption = true;
        m_MashUpWorlds.SetShow(TRUE);
    } else {
        m_bMashUpWorldsUnhideOption = false;
        m_MashUpWorlds.SetShow(FALSE);
    }

    // Display the tooltips
    HRESULT hr = S_OK;
    HXUIOBJ hSlider;

    unsigned char ucValue = app.GetGameSettings(m_iPad, eGameSetting_Autosave);
    m_SliderA[SLIDER_SETTINGS_AUTOSAVE].SetValue(ucValue);
    if (ucValue == 0) {
        swprintf((WCHAR*)TempString, 256, L"%ls",
                 app.GetString(IDS_SLIDER_AUTOSAVE_OFF));
    } else {
        swprintf((WCHAR*)TempString, 256, L"%ls: %d %ls",
                 app.GetString(IDS_SLIDER_AUTOSAVE), ucValue * 15,
                 app.GetString(IDS_MINUTES));
    }

    m_SliderA[SLIDER_SETTINGS_AUTOSAVE].SetText(TempString);

    m_ViewBob.SetCheck((app.GetGameSettings(m_iPad, eGameSetting_ViewBob) != 0)
                           ? TRUE
                           : FALSE);
    m_InGameGamertags.SetCheck(
        (app.GetGameSettings(m_iPad, eGameSetting_GamertagsVisible) != 0)
            ? TRUE
            : FALSE);
    m_Hints.SetCheck(
        (app.GetGameSettings(m_iPad, eGameSetting_Hints) != 0) ? TRUE : FALSE);
    m_Tooltips.SetCheck(
        (app.GetGameSettings(m_iPad, eGameSetting_Tooltips) != 0) ? TRUE
                                                                  : FALSE);

    m_SliderA[SLIDER_SETTINGS_DIFFICULTY].SetValue(
        app.GetGameSettings(m_iPad, eGameSetting_Difficulty));
    swprintf((WCHAR*)TempString, 256, L"%ls: %ls",
             app.GetString(IDS_SLIDER_DIFFICULTY),
             app.GetString(m_iDifficultyTitleSettingA[app.GetGameSettings(
                 m_iPad, eGameSetting_Difficulty)]));
    m_SliderA[SLIDER_SETTINGS_DIFFICULTY].SetText(TempString);

    std::wstring wsText =
        app.GetString(m_iDifficultySettingA[app.GetGameSettings(
            m_iPad, eGameSetting_Difficulty)]);
    int size = 14;
    if (!RenderManager.IsHiDef() && !RenderManager.IsWidescreen()) {
        size = 12;
    }
    wchar_t startTags[64];
    swprintf(startTags, 64, L"<font color=\"#%08x\" size=%d>",
             app.GetHTMLColour(eHTMLColor_White), size);
    wsText = startTags + wsText;

    m_DifficultyText.SetText(wsText.c_str());

    // If you are in-game, only the game host can change in-game gamertags, and
    // you can't change difficulty only the primary player gets to change the
    // autosave and difficulty settings

    bool bRemoveDifficulty = false;
    bool bRemoveAutosave = false;
    bool bRemoveInGameGamertags = false;
    float fRemoveHeight = 0.0f, fWidth, fHeight;
    float fSlidersMoveUp = 0.0f;

    if (!bPrimaryPlayer) {
        bRemoveDifficulty = true;
        bRemoveAutosave = true;
        bRemoveInGameGamertags = true;
    }

    if (!bNotInGame)  // in the game
    {
        bRemoveDifficulty = true;
        if (!g_NetworkManager.IsHost()) {
            bRemoveAutosave = true;
            bRemoveInGameGamertags = true;
        }
    }

    D3DXVECTOR3 vec1, vec2;
    XuiElementGetPosition(m_ViewBob, &vec1);
    XuiElementGetPosition(m_Hints, &vec2);

    float fCheckboxHeight = vec2.y - vec1.y;

    if (bRemoveDifficulty) {
        m_SliderA[SLIDER_SETTINGS_DIFFICULTY].SetEnable(FALSE);
        m_SliderA[SLIDER_SETTINGS_DIFFICULTY].SetShow(FALSE);
        m_DifficultyText.SetShow(FALSE);
        hr =
            XuiElementGetChildById(m_SliderA[SLIDER_SETTINGS_DIFFICULTY].m_hObj,
                                   L"XuiSlider", &hSlider);
        XuiElementSetShow(hSlider, FALSE);
        XuiControlSetEnable(hSlider, FALSE);
        m_SliderA[SLIDER_SETTINGS_DIFFICULTY].GetBounds(&fWidth, &fHeight);
        fRemoveHeight += fHeight + 4.0f;  // add padding
    } else {
        std::wstring wsText =
            app.GetString(m_iDifficultySettingA[app.GetGameSettings(
                m_iPad, eGameSetting_Difficulty)]);
        int size = 14;
        if (!RenderManager.IsHiDef() && !RenderManager.IsWidescreen()) {
            size = 12;
        }
        wchar_t startTags[64];
        swprintf(startTags, 64, L"<font color=\"#%08x\" size=%d>",
                 app.GetHTMLColour(eHTMLColor_White), size);
        wsText = startTags + wsText;

        m_DifficultyText.SetText(wsText.c_str());
    }

    if (bRemoveAutosave) {
        m_SliderA[SLIDER_SETTINGS_AUTOSAVE].SetEnable(FALSE);
        m_SliderA[SLIDER_SETTINGS_AUTOSAVE].SetShow(FALSE);
        hr = XuiElementGetChildById(m_SliderA[SLIDER_SETTINGS_AUTOSAVE].m_hObj,
                                    L"XuiSlider", &hSlider);
        XuiElementSetShow(hSlider, FALSE);
        XuiControlSetEnable(hSlider, FALSE);
        m_SliderA[SLIDER_SETTINGS_AUTOSAVE].GetBounds(&fWidth, &fHeight);
        fRemoveHeight += fHeight + 4.0f;  // add padding
    }

    if (bRemoveInGameGamertags) {
        m_InGameGamertags.SetShow(FALSE);
        m_InGameGamertags.SetEnable(FALSE);
        m_InGameGamertags.GetBounds(&fWidth, &fHeight);

        // move the mash-up worlds option up
        if (m_bMashUpWorldsUnhideOption) {
            D3DXVECTOR3 vec;
            XuiElementGetPosition(m_InGameGamertags, &vec);
            m_MashUpWorlds.SetPosition(&vec);
        }
        fRemoveHeight += fCheckboxHeight;  // fHeight+4.0f; // add padding
        fSlidersMoveUp += fCheckboxHeight;
    }

    if (!m_bMashUpWorldsUnhideOption) {
        m_MashUpWorlds.SetShow(FALSE);
        m_MashUpWorlds.SetEnable(FALSE);
        m_MashUpWorlds.GetBounds(&fWidth, &fHeight);
        fRemoveHeight += fCheckboxHeight;
        fSlidersMoveUp += fCheckboxHeight;
    }

    if (fRemoveHeight > 0.0f) {
        D3DXVECTOR3 vec;
        // autosave should move up by the height of the number of checkboxes
        // hidden
        m_SliderA[SLIDER_SETTINGS_AUTOSAVE].GetPosition(&vec);
        vec.y -= fSlidersMoveUp;
        m_SliderA[SLIDER_SETTINGS_AUTOSAVE].SetPosition(&vec);
        m_SliderA[SLIDER_SETTINGS_DIFFICULTY].GetPosition(&vec);
        vec.y -= fSlidersMoveUp;
        m_SliderA[SLIDER_SETTINGS_DIFFICULTY].SetPosition(&vec);
        m_DifficultyText.GetPosition(&vec);
        vec.y -= fSlidersMoveUp;
        m_DifficultyText.SetPosition(&vec);

        float fbgnWidth, fBgnHeight;
        GetBounds(&fbgnWidth, &fBgnHeight);
        fBgnHeight -= fRemoveHeight;
        SetBounds(fbgnWidth, fBgnHeight);
    }

    // if we're not in the game, we need to use basescene 0
    if (bNotInGame) {
        ui.SetTooltips(DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT,
                       IDS_TOOLTIPS_BACK);
        CXuiSceneBase::ShowBackground(DEFAULT_XUI_MENU_USER, TRUE);
    } else {
        ui.SetTooltips(m_iPad, IDS_TOOLTIPS_SELECT, IDS_TOOLTIPS_BACK);
        CXuiSceneBase::ShowBackground(m_iPad, FALSE);
    }

    if (app.GetLocalPlayerCount() > 1) {
        app.AdjustSplitscreenScene(m_hObj, &m_OriginalPosition, m_iPad);
        CXuiSceneBase::ShowLogo(m_iPad, FALSE);
    } else {
        if (bNotInGame) {
            // can't show the logo for 480 mode
            if (!RenderManager.IsHiDef()) {
                CXuiSceneBase::ShowLogo(DEFAULT_XUI_MENU_USER, FALSE);
            } else {
                CXuiSceneBase::ShowLogo(DEFAULT_XUI_MENU_USER, TRUE);
            }
        } else {
            // can't show the logo for 480 mode
            if (!RenderManager.IsHiDef()) {
                CXuiSceneBase::ShowLogo(m_iPad, FALSE);
            } else {
                CXuiSceneBase::ShowLogo(m_iPad, TRUE);
            }
        }
    }

    return S_OK;
}

HRESULT CScene_SettingsOptions::OnNotifyValueChanged(
    HXUIOBJ hObjSource, XUINotifyValueChanged* pNotifyValueChanged,
    BOOL& bHandled) {
    WCHAR TempString[256];

    if (hObjSource == m_SliderA[SLIDER_SETTINGS_AUTOSAVE].GetSlider()) {
        app.SetGameSettings(m_iPad, eGameSetting_Autosave,
                            pNotifyValueChanged->nValue);
        // Update the autosave timer
        app.SetAutosaveTimerTime();

        if (pNotifyValueChanged->nValue == 0) {
            swprintf((WCHAR*)TempString, 256, L"%ls",
                     app.GetString(IDS_SLIDER_AUTOSAVE_OFF));
        } else {
            app.SetAutosaveTimerTime();
            swprintf((WCHAR*)TempString, 256, L"%ls: %d %ls",
                     app.GetString(IDS_SLIDER_AUTOSAVE),
                     pNotifyValueChanged->nValue * 15,
                     app.GetString(IDS_MINUTES));
        }
        m_SliderA[SLIDER_SETTINGS_AUTOSAVE].SetText(TempString);
    } else if (hObjSource ==
               m_SliderA[SLIDER_SETTINGS_DIFFICULTY].GetSlider()) {
        app.SetGameSettings(m_iPad, eGameSetting_Difficulty,
                            pNotifyValueChanged->nValue);
        swprintf((WCHAR*)TempString, 256, L"%ls: %ls",
                 app.GetString(IDS_SLIDER_DIFFICULTY),
                 app.GetString(
                     m_iDifficultyTitleSettingA[pNotifyValueChanged->nValue]));
        m_SliderA[SLIDER_SETTINGS_DIFFICULTY].SetText(TempString);

        std::wstring wsText =
            app.GetString(m_iDifficultySettingA[pNotifyValueChanged->nValue]);
        int size = 14;
        if (!RenderManager.IsHiDef() && !RenderManager.IsWidescreen()) {
            size = 12;
        }
        wchar_t startTags[64];
        swprintf(startTags, 64, L"<font color=\"#%08x\" size=%d>",
                 app.GetHTMLColour(eHTMLColor_White), size);
        wsText = startTags + wsText;
        m_DifficultyText.SetText(wsText.c_str());
    }
    return S_OK;
}

HRESULT CScene_SettingsOptions::OnKeyDown(XUIMessageInput* pInputData,
                                          BOOL& rfHandled) {
    ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);

    HRESULT hr = S_OK;

    // Explicitly handle B button presses
    switch (pInputData->dwKeyCode) {
        case VK_PAD_B:
        case VK_ESCAPE:
            // if the profile data has been changed, then force a profile write
            // It seems we're allowed to break the 5 minute rule if it's the
            // result of a user action

            // check the checkboxes
            app.SetGameSettings(m_iPad, eGameSetting_ViewBob,
                                m_ViewBob.IsChecked() ? 1 : 0);
            app.SetGameSettings(m_iPad, eGameSetting_GamertagsVisible,
                                m_InGameGamertags.IsChecked() ? 1 : 0);
            app.SetGameSettings(m_iPad, eGameSetting_Hints,
                                m_Hints.IsChecked() ? 1 : 0);
            app.SetGameSettings(m_iPad, eGameSetting_Tooltips,
                                m_Tooltips.IsChecked() ? 1 : 0);

            // the mashup option will only be shown if some worlds have been
            // previously hidden
            if (m_bMashUpWorldsUnhideOption && m_MashUpWorlds.IsChecked()) {
                // unhide all worlds
                app.EnableMashupPackWorlds(m_iPad);
            }

            // 4J-PB - don't action changes here or we might write to the
            // profile on backing out here and then get a change in the settings
            // all, and write again on backing out there
            // app.CheckGameSettingsChanged(true,pInputData->UserIndex);

            app.NavigateBack(pInputData->UserIndex);
            rfHandled = TRUE;
            break;
    }

    return hr;
}

//----------------------------------------------------------------------------------
// Handler for the button press message.
//----------------------------------------------------------------------------------
HRESULT CScene_SettingsOptions::OnNotifyPressEx(
    HXUIOBJ hObjPressed, XUINotifyPress* pNotifyPressData, BOOL& rfHandled) {
    // This assumes all buttons can only be pressed with the A button
    ui.AnimateKeyPress(pNotifyPressData->UserIndex, VK_PAD_A);

    return S_OK;
}

HRESULT CScene_SettingsOptions::OnControlNavigate(
    XUIMessageControlNavigate* pControlNavigateData, BOOL& bHandled) {
    // added so we can skip greyed out items
    pControlNavigateData->hObjDest = XuiControlGetNavigation(
        pControlNavigateData->hObjSource,
        pControlNavigateData->nControlNavigate, TRUE, TRUE);

    if (pControlNavigateData->hObjDest != NULL) {
        bHandled = TRUE;
    }

    return S_OK;
}

HRESULT CScene_SettingsOptions::OnTransitionStart(
    XUIMessageTransition* pTransition, BOOL& bHandled) {
    HRESULT hr;
    WCHAR TempString[256];

    if (pTransition->dwTransAction == XUI_TRANSITION_ACTION_DESTROY)
        return S_OK;

    if (pTransition->dwTransType == XUI_TRANSITION_TO ||
        pTransition->dwTransType == XUI_TRANSITION_BACKTO) {
        // 4J-PB - Going to resize buttons if the text is too big to fit on any
        // of them (Br-pt problem with the length of Unlock Full Game)

        float fMaxTextLen = 0.0f;
        float fMaxLen = 0.0f;

        // sliders first
        HXUIOBJ hSlider, hVisual, hText, hCheckboxText;
        XUIRect xuiRect;
        float fWidth, fHeight;  //,fTemp;
        D3DXVECTOR3 vec, vSlider, vecCheckboxText, vecCheckbox;

        // don't display values on these - we handle that
        for (int i = 0; i < OPTIONS_SLIDER_SETTINGS_MAX; i++) {
            m_SliderA[i].SetValueDisplay(FALSE);
        }

        hr = XuiElementGetChildById(m_SliderA[SLIDER_SETTINGS_AUTOSAVE].m_hObj,
                                    L"XuiSlider", &hSlider);
        hr = XuiControlGetVisual(hSlider, &hVisual);
        hr = XuiElementGetChildById(hVisual, L"text_Label", &hText);
        hr = XuiControlGetVisual(m_InGameGamertags.m_hObj, &hVisual);
        hr = XuiElementGetChildById(hVisual, L"text_Button", &hCheckboxText);
        hr = XuiElementGetPosition(hCheckboxText, &vecCheckboxText);
        hr = XuiElementGetPosition(m_InGameGamertags.m_hObj, &vecCheckbox);
        hr = XuiElementGetPosition(m_SliderA[SLIDER_SETTINGS_AUTOSAVE].m_hObj,
                                   &vSlider);

        for (int i = 0; i < OPTIONS_SLIDER_SETTINGS_MAX; i++) {
            switch (i) {
                case SLIDER_SETTINGS_AUTOSAVE:  // 3 digits
                    swprintf((WCHAR*)TempString, 256, L"%ls: %d %ls",
                             app.GetString(IDS_SLIDER_AUTOSAVE), 999,
                             app.GetString(IDS_MINUTES));
                    break;
                case SLIDER_SETTINGS_DIFFICULTY:  // 3 digits
                    swprintf((WCHAR*)TempString, 256, L"%ls: %ls",
                             app.GetString(IDS_SLIDER_DIFFICULTY),
                             app.GetString(IDS_DIFFICULTY_TITLE_PEACEFUL));
                    break;
            }

            // LPCWSTR temp=m_SliderA[i].GetText();
            hr = XuiTextPresenterMeasureText(hText, TempString, &xuiRect);
            // 4J-PB - the text measuring doesn't seem to be long enough - add a
            // fudge
            xuiRect.right += 25.0f;
            m_SliderA[i].GetBounds(&fWidth, &fHeight);
            if (xuiRect.right > fMaxTextLen) fMaxTextLen = xuiRect.right;
            if (fWidth > fMaxLen) fMaxLen = fWidth;
        }

        // now the VisibleOnMaps checkbox - let's just use the visual we already
        // have...
        hr = XuiTextPresenterMeasureText(hCheckboxText,
                                         m_InGameGamertags.GetText(), &xuiRect);
        m_InGameGamertags.GetBounds(&fWidth, &fHeight);
        // need to add the size of the checkbox graphic
        if ((xuiRect.right + vecCheckbox.x + vecCheckboxText.x) > fMaxTextLen)
            fMaxTextLen = xuiRect.right + vecCheckbox.x + vecCheckboxText.x;
        if (fWidth > fMaxLen) fMaxLen = fWidth;

        // now the m_Hints checkbox - let's just use the visual we already
        // have...
        hr = XuiTextPresenterMeasureText(hCheckboxText, m_Hints.GetText(),
                                         &xuiRect);
        m_Hints.GetBounds(&fWidth, &fHeight);
        // need to add the size of the checkbox graphic
        if ((xuiRect.right + vecCheckbox.x + vecCheckboxText.x) > fMaxTextLen)
            fMaxTextLen = xuiRect.right + vecCheckbox.x + vecCheckboxText.x;
        if (fWidth > fMaxLen) fMaxLen = fWidth;

        // now the m_Tooltips checkbox - let's just use the visual we already
        // have...
        hr = XuiTextPresenterMeasureText(hCheckboxText, m_Tooltips.GetText(),
                                         &xuiRect);
        m_Tooltips.GetBounds(&fWidth, &fHeight);
        // need to add the size of the checkbox graphic
        if ((xuiRect.right + vecCheckbox.x + vecCheckboxText.x) > fMaxTextLen)
            fMaxTextLen = xuiRect.right + vecCheckbox.x + vecCheckboxText.x;
        if (fWidth > fMaxLen) fMaxLen = fWidth;

        if (fMaxLen < fMaxTextLen) {
            float fWidth;
            XuiElementGetPosition(m_hObj, &vec);
            XuiElementGetBounds(m_hObj, &fWidth, &fHeight);

            // need to centre the scene now the size has changed
            if ((!RenderManager.IsHiDef() && !RenderManager.IsWidescreen()) ||
                app.GetLocalPlayerCount() > 1) {
                // scene width needs to be more that the text width on buttons
                fWidth = vSlider.x;
                vec.x = floorf((640.0f - (fMaxTextLen + fWidth)) / 2.0f);
                XuiElementSetPosition(m_hObj, &vec);
                XuiElementSetBounds(m_hObj, fMaxTextLen + (fWidth * 2.0f),
                                    fHeight);
            } else {
                fWidth = vSlider.x;
                vec.x = floorf((1280.0f - (fMaxTextLen + fWidth)) / 2.0f);
                XuiElementSetPosition(m_hObj, &vec);
                XuiElementSetBounds(m_hObj, fMaxTextLen + (fWidth * 2.0f),
                                    fHeight);
            }
            // Need to refresh the scenes visual since the object size has now
            // changed
            XuiControlAttachVisual(m_hObj);

            bool bNotInGame = (Minecraft::GetInstance()->level == NULL);

            if (bNotInGame) {
                float fDiffTextW;
                // reposition the difficulty text - this is positioned from the
                // scene, so will be a negative value
                m_DifficultyText.GetPosition(&vec);
                m_DifficultyText.GetBounds(&fDiffTextW, &fHeight);
                vec.x =
                    floor((fMaxTextLen + (fWidth * 2.0f) - fDiffTextW) / 2.0f);
                m_DifficultyText.SetPosition(&vec);
            }

            // centre is vec.x+(fWidth/2)
            // for(int i=0;i<OPTIONS_SLIDER_SETTINGS_MAX;i++)
            //{
            //	hr=XuiElementGetChildById(m_SliderA[i].m_hObj,L"XuiSlider",&hSlider);
            //	XuiElementGetPosition(hSlider,&vec);
            //	XuiElementGetBounds(hSlider,&fTemp,&fHeight);
            //	XuiElementSetBounds(hSlider,fMaxTextLen,fHeight);
            //}

            // the checkboxes are left aligned - put them at the same position
            // as the sliders
            m_ViewBob.SetBounds(fMaxTextLen, fHeight);
            m_InGameGamertags.SetBounds(fMaxTextLen, fHeight);
            m_Hints.SetBounds(fMaxTextLen, fHeight);
            m_Tooltips.SetBounds(fMaxTextLen, fHeight);
        }
    }

    return S_OK;
}

HRESULT CScene_SettingsOptions::OnCustomMessage_Splitscreenplayer(
    bool bJoining, BOOL& bHandled) {
    bHandled = true;
    return app.AdjustSplitscreenScene_PlayerChanged(m_hObj, &m_OriginalPosition,
                                                    m_iPad, bJoining);
}