/*****************************************************************************
 * Copyright (c) 2014-2024 OpenRCT2 developers
 *
 * For a complete list of all authors, please refer to contributors.md
 * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
 *
 * OpenRCT2 is licensed under the GNU General Public License version 3.
 *****************************************************************************/

#include <algorithm>
#include <openrct2-ui/interface/Dropdown.h>
#include <openrct2-ui/interface/LandTool.h>
#include <openrct2-ui/interface/Widget.h>
#include <openrct2-ui/windows/Window.h>
#include <openrct2/Context.h>
#include <openrct2/Input.h>
#include <openrct2/drawing/Drawing.h>
#include <openrct2/localisation/Formatter.h>
#include <openrct2/localisation/Localisation.h>
#include <openrct2/object/ObjectManager.h>
#include <openrct2/object/TerrainEdgeObject.h>
#include <openrct2/object/TerrainSurfaceObject.h>
#include <openrct2/util/Util.h>
#include <openrct2/windows/Intent.h>
#include <openrct2/world/MapGen.h>
#include <openrct2/world/Surface.h>

namespace OpenRCT2::Ui::Windows
{
    enum
    {
        WINDOW_MAPGEN_PAGE_BASE,
        WINDOW_MAPGEN_PAGE_RANDOM,
        WINDOW_MAPGEN_PAGE_SIMPLEX,
        WINDOW_MAPGEN_PAGE_HEIGHTMAP,
        WINDOW_MAPGEN_PAGE_COUNT
    };

    enum
    {
        WIDX_BACKGROUND,
        WIDX_TITLE,
        WIDX_CLOSE,
        WIDX_PAGE_BACKGROUND,
        WIDX_TAB_1,
        WIDX_TAB_2,
        WIDX_TAB_3,
        WIDX_TAB_4,

        TAB_BEGIN,

        WIDX_MAP_GENERATE = TAB_BEGIN,
        WIDX_MAP_SIZE_Y,
        WIDX_MAP_SIZE_Y_UP,
        WIDX_MAP_SIZE_Y_DOWN,
        WIDX_MAP_SIZE_LINK,
        WIDX_MAP_SIZE_X,
        WIDX_MAP_SIZE_X_UP,
        WIDX_MAP_SIZE_X_DOWN,
        WIDX_BASE_HEIGHT,
        WIDX_BASE_HEIGHT_UP,
        WIDX_BASE_HEIGHT_DOWN,
        WIDX_WATER_LEVEL,
        WIDX_WATER_LEVEL_UP,
        WIDX_WATER_LEVEL_DOWN,
        WIDX_FLOOR_TEXTURE,
        WIDX_WALL_TEXTURE,

        WIDX_RANDOM_GENERATE = TAB_BEGIN,
        WIDX_RANDOM_TERRAIN,
        WIDX_RANDOM_PLACE_TREES,

        WIDX_SIMPLEX_GENERATE = TAB_BEGIN,
        WIDX_SIMPLEX_LABEL,
        WIDX_SIMPLEX_LOW,
        WIDX_SIMPLEX_LOW_UP,
        WIDX_SIMPLEX_LOW_DOWN,
        WIDX_SIMPLEX_HIGH,
        WIDX_SIMPLEX_HIGH_UP,
        WIDX_SIMPLEX_HIGH_DOWN,
        WIDX_SIMPLEX_BASE_FREQ,
        WIDX_SIMPLEX_BASE_FREQ_UP,
        WIDX_SIMPLEX_BASE_FREQ_DOWN,
        WIDX_SIMPLEX_OCTAVES,
        WIDX_SIMPLEX_OCTAVES_UP,
        WIDX_SIMPLEX_OCTAVES_DOWN,
        WIDX_SIMPLEX_MAP_SIZE_Y,
        WIDX_SIMPLEX_MAP_SIZE_Y_UP,
        WIDX_SIMPLEX_MAP_SIZE_Y_DOWN,
        WIDX_SIMPLEX_MAP_SIZE_LINK,
        WIDX_SIMPLEX_MAP_SIZE_X,
        WIDX_SIMPLEX_MAP_SIZE_X_UP,
        WIDX_SIMPLEX_MAP_SIZE_X_DOWN,
        WIDX_SIMPLEX_WATER_LEVEL,
        WIDX_SIMPLEX_WATER_LEVEL_UP,
        WIDX_SIMPLEX_WATER_LEVEL_DOWN,
        WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX,
        WIDX_SIMPLEX_FLOOR_TEXTURE,
        WIDX_SIMPLEX_WALL_TEXTURE,
        WIDX_SIMPLEX_PLACE_TREES_CHECKBOX,

        WIDX_HEIGHTMAP_SELECT = TAB_BEGIN,
        WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP,
        WIDX_HEIGHTMAP_STRENGTH,
        WIDX_HEIGHTMAP_STRENGTH_UP,
        WIDX_HEIGHTMAP_STRENGTH_DOWN,
        WIDX_HEIGHTMAP_NORMALIZE,
        WIDX_HEIGHTMAP_SMOOTH_TILES,
        WIDX_HEIGHTMAP_LOW,
        WIDX_HEIGHTMAP_LOW_UP,
        WIDX_HEIGHTMAP_LOW_DOWN,
        WIDX_HEIGHTMAP_HIGH,
        WIDX_HEIGHTMAP_HIGH_UP,
        WIDX_HEIGHTMAP_HIGH_DOWN,
        WIDX_HEIGHTMAP_WATER_LEVEL,
        WIDX_HEIGHTMAP_WATER_LEVEL_UP,
        WIDX_HEIGHTMAP_WATER_LEVEL_DOWN,
    };

#pragma region Widgets

    static constexpr StringId WINDOW_TITLE = STR_MAPGEN_WINDOW_TITLE;
    static constexpr int32_t WW = 250;
    static constexpr int32_t WH = 273;

    // clang-format off
#define SHARED_WIDGETS \
    WINDOW_SHIM(WINDOW_TITLE, WW, WH), /* WIDX_BACKGROUND, WIDX_TITLE, WIDX_CLOSE */ \
    MakeWidget({ 0, 43}, {WW, 229}, WindowWidgetType::Resize, WindowColour::Secondary), /* WIDX_PAGE_BACKGROUND */ \
    MakeTab   ({ 3, 17}                                                ), /* WIDX_TAB_1 */ \
    MakeTab   ({34, 17}                                                ), /* WIDX_TAB_2 */ \
    MakeTab   ({65, 17}                                                ), /* WIDX_TAB_3 */ \
    MakeTab   ({96, 17}                                                )  /* WIDX_TAB_4 */

static Widget MapWidgets[] = {
    SHARED_WIDGETS,
    MakeWidget        ({155, 255}, {90, 14}, WindowWidgetType::Button,  WindowColour::Secondary, STR_MAPGEN_ACTION_GENERATE                                 ),
    MakeSpinnerWidgets({104,  52}, {50, 12}, WindowWidgetType::Spinner, WindowColour::Secondary, STR_COMMA16                                                ), // NB: 3 widgets
    MakeWidget        ({155,  52}, {21, 12}, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_G2_LINK_CHAIN),          STR_MAINTAIN_SQUARE_MAP_TOOLTIP),
    MakeSpinnerWidgets({177,  52}, {50, 12}, WindowWidgetType::Spinner, WindowColour::Secondary, STR_POP16_COMMA16                                          ), // NB: 3 widgets
    MakeSpinnerWidgets({104,  70}, {95, 12}, WindowWidgetType::Spinner, WindowColour::Secondary                                                             ), // NB: 3 widgets
    MakeSpinnerWidgets({104,  88}, {95, 12}, WindowWidgetType::Spinner, WindowColour::Secondary                                                             ), // NB: 3 widgets
    MakeWidget        ({104, 106}, {47, 36}, WindowWidgetType::FlatBtn, WindowColour::Secondary, 0xFFFFFFFF,                 STR_CHANGE_BASE_LAND_TIP       ),
    MakeWidget        ({151, 106}, {47, 36}, WindowWidgetType::FlatBtn, WindowColour::Secondary, 0xFFFFFFFF,                 STR_CHANGE_VERTICAL_LAND_TIP   ),
    kWidgetsEnd,
};

static Widget RandomWidgets[] = {
    SHARED_WIDGETS,
    MakeWidget({155, 255}, { 90, 14}, WindowWidgetType::Button,   WindowColour::Secondary, STR_MAPGEN_ACTION_GENERATE      ),
    MakeWidget({  4,  52}, {195, 12}, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_MAPGEN_OPTION_RANDOM_TERRAIN),
    MakeWidget({  4,  70}, {195, 12}, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_MAPGEN_OPTION_PLACE_TREES   ),
    kWidgetsEnd,
};

static Widget SimplexWidgets[] = {
    SHARED_WIDGETS,
    MakeWidget        ({155, 255}, { 90, 14}, WindowWidgetType::Button,        WindowColour::Secondary, STR_MAPGEN_ACTION_GENERATE                                       ), // WIDX_SIMPLEX_GENERATE
    MakeWidget        ({  4,  52}, {195, 12}, WindowWidgetType::LabelCentred,  WindowColour::Secondary, STR_MAPGEN_SIMPLEX_NOISE                                         ), // WIDX_SIMPLEX_LABEL
    MakeSpinnerWidgets({104,  70}, { 95, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary                                                                   ), // WIDX_SIMPLEX_LOW{,_UP,_DOWN}
    MakeSpinnerWidgets({104,  88}, { 95, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary                                                                   ), // WIDX_SIMPLEX_HIGH{,_UP,_DOWN}
    MakeSpinnerWidgets({104, 106}, { 95, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary                                                                   ), // WIDX_SIMPLEX_BASE_FREQ{,_UP,_DOWN}
    MakeSpinnerWidgets({104, 124}, { 95, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary                                                                   ), // WIDX_SIMPLEX_OCTAVES{,_UP,_DOWN}
    MakeSpinnerWidgets({104, 148}, { 50, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary, STR_COMMA16                                                      ), // WIDX_SIMPLEX_MAP_SIZE_Y{,_UP,_DOWN}
    MakeWidget        ({155, 148}, { 21, 12}, WindowWidgetType::FlatBtn,       WindowColour::Secondary, ImageId(SPR_G2_LINK_CHAIN),                STR_MAINTAIN_SQUARE_MAP_TOOLTIP), // WIDX_SIMPLEX_MAP_SIZE_LINK
    MakeSpinnerWidgets({177, 148}, { 50, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary, STR_POP16_COMMA16                                                ), // WIDX_SIMPLEX_MAP_SIZE_X{,_UP,_DOWN}
    MakeSpinnerWidgets({104, 166}, { 95, 12}, WindowWidgetType::Spinner,       WindowColour::Secondary                                                                   ), // WIDX_SIMPLEX_WATER_LEVEL{,_UP,_DOWN}
    MakeWidget        ({104, 190}, { 95, 12}, WindowWidgetType::Checkbox,      WindowColour::Secondary, STR_MAPGEN_OPTION_RANDOM_TERRAIN                                 ), // WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX
    MakeWidget        ({102, 202}, { 47, 36}, WindowWidgetType::FlatBtn,       WindowColour::Secondary, 0xFFFFFFFF,                       STR_CHANGE_BASE_LAND_TIP       ), // WIDX_SIMPLEX_FLOOR_TEXTURE
    MakeWidget        ({150, 202}, { 47, 36}, WindowWidgetType::FlatBtn,       WindowColour::Secondary, 0xFFFFFFFF,                       STR_CHANGE_VERTICAL_LAND_TIP   ), // WIDX_SIMPLEX_WALL_TEXTURE
    MakeWidget        ({104, 239}, { 95, 12}, WindowWidgetType::Checkbox,      WindowColour::Secondary                                                                   ), // WIDX_SIMPLEX_PLACE_TREES_CHECKBOX
    kWidgetsEnd,
};

static Widget HeightmapWidgets[] = {
    SHARED_WIDGETS,
    MakeWidget        ({ 95, 255}, {150, 14}, WindowWidgetType::Button,   WindowColour::Secondary, STR_MAPGEN_SELECT_HEIGHTMAP), // WIDX_HEIGHTMAP_SELECT
    MakeWidget        ({  4,  52}, {100, 12}, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_MAPGEN_SMOOTH_HEIGHTMAP), // WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP
    MakeSpinnerWidgets({104,  70}, { 95, 12}, WindowWidgetType::Spinner,  WindowColour::Secondary                             ), // WIDX_HEIGHTMAP_STRENGTH{,_UP,_DOWN}
    MakeWidget        ({  4,  88}, {100, 12}, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_MAPGEN_NORMALIZE       ), // WIDX_HEIGHTMAP_NORMALIZE
    MakeWidget        ({  4, 106}, {100, 12}, WindowWidgetType::Checkbox, WindowColour::Secondary, STR_MAPGEN_SMOOTH_TILE     ), // WIDX_HEIGHTMAP_SMOOTH_TILES
    MakeSpinnerWidgets({104, 124}, { 95, 12}, WindowWidgetType::Spinner,  WindowColour::Secondary                             ), // WIDX_HEIGHTMAP_LOW{,_UP,_DOWN}
    MakeSpinnerWidgets({104, 142}, { 95, 12}, WindowWidgetType::Spinner,  WindowColour::Secondary                             ), // WIDX_HEIGHTMAP_HIGH{,_UP,_DOWN}
    MakeSpinnerWidgets({104, 160}, { 95, 12}, WindowWidgetType::Spinner,  WindowColour::Secondary                             ), // WIDX_HEIGHTMAP_WATER_LEVEL{,_UP,_DOWN}
    kWidgetsEnd,
};
    // clang-format on

    static Widget* PageWidgets[WINDOW_MAPGEN_PAGE_COUNT] = {
        MapWidgets,
        RandomWidgets,
        SimplexWidgets,
        HeightmapWidgets,
    };

#pragma endregion

#pragma region Widget flags

    // clang-format off
static uint64_t PageDisabledWidgets[WINDOW_MAPGEN_PAGE_COUNT] = {
    0,

    0,

    0,

    (1uLL << WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP) |
    (1uLL << WIDX_HEIGHTMAP_STRENGTH) |
    (1uLL << WIDX_HEIGHTMAP_STRENGTH_UP) |
    (1uLL << WIDX_HEIGHTMAP_STRENGTH_DOWN) |
    (1uLL << WIDX_HEIGHTMAP_NORMALIZE) |
    (1uLL << WIDX_HEIGHTMAP_SMOOTH_TILES) |
    (1uLL << WIDX_HEIGHTMAP_HIGH) |
    (1uLL << WIDX_HEIGHTMAP_HIGH_UP) |
    (1uLL << WIDX_HEIGHTMAP_HIGH_DOWN) |
    (1uLL << WIDX_HEIGHTMAP_LOW) |
    (1uLL << WIDX_HEIGHTMAP_LOW_UP) |
    (1uLL << WIDX_HEIGHTMAP_LOW_DOWN) |
    (1uLL << WIDX_HEIGHTMAP_WATER_LEVEL) |
    (1uLL << WIDX_HEIGHTMAP_WATER_LEVEL_UP) |
    (1uLL << WIDX_HEIGHTMAP_WATER_LEVEL_DOWN)
};

static uint64_t HoldDownWidgets[WINDOW_MAPGEN_PAGE_COUNT] = {
    (1uLL << WIDX_MAP_SIZE_Y_UP) |
    (1uLL << WIDX_MAP_SIZE_Y_DOWN) |
    (1uLL << WIDX_MAP_SIZE_X_UP) |
    (1uLL << WIDX_MAP_SIZE_X_DOWN) |
    (1uLL << WIDX_BASE_HEIGHT_UP) |
    (1uLL << WIDX_BASE_HEIGHT_DOWN) |
    (1uLL << WIDX_WATER_LEVEL_UP) |
    (1uLL << WIDX_WATER_LEVEL_DOWN),

    0,

    (1uLL << WIDX_SIMPLEX_LOW_UP) |
    (1uLL << WIDX_SIMPLEX_LOW_DOWN) |
    (1uLL << WIDX_SIMPLEX_HIGH_UP) |
    (1uLL << WIDX_SIMPLEX_HIGH_DOWN) |
    (1uLL << WIDX_SIMPLEX_BASE_FREQ_UP) |
    (1uLL << WIDX_SIMPLEX_BASE_FREQ_DOWN) |
    (1uLL << WIDX_SIMPLEX_OCTAVES_UP) |
    (1uLL << WIDX_SIMPLEX_OCTAVES_DOWN) |
    (1uLL << WIDX_SIMPLEX_MAP_SIZE_Y_UP) |
    (1uLL << WIDX_SIMPLEX_MAP_SIZE_Y_DOWN) |
    (1uLL << WIDX_SIMPLEX_MAP_SIZE_X_UP) |
    (1uLL << WIDX_SIMPLEX_MAP_SIZE_X_DOWN) |
    (1uLL << WIDX_SIMPLEX_WATER_LEVEL_UP) |
    (1uLL << WIDX_SIMPLEX_WATER_LEVEL_DOWN),

    (1uLL << WIDX_HEIGHTMAP_STRENGTH_UP) |
    (1uLL << WIDX_HEIGHTMAP_STRENGTH_DOWN) |
    (1uLL << WIDX_HEIGHTMAP_LOW_UP) |
    (1uLL << WIDX_HEIGHTMAP_LOW_DOWN) |
    (1uLL << WIDX_HEIGHTMAP_HIGH_UP) |
    (1uLL << WIDX_HEIGHTMAP_HIGH_DOWN) |
    (1uLL << WIDX_HEIGHTMAP_WATER_LEVEL_UP) |
    (1uLL << WIDX_HEIGHTMAP_WATER_LEVEL_DOWN)
};

static uint64_t PressedWidgets[WINDOW_MAPGEN_PAGE_COUNT] = {
    0,
    0,
    0,
    (1uLL << WIDX_HEIGHTMAP_SMOOTH_TILES)
};
    // clang-format on

#pragma endregion

    static constexpr int32_t TabAnimationDivisor[WINDOW_MAPGEN_PAGE_COUNT] = {
        1,
        1,
        1,
        1,
    };
    static constexpr int32_t TabAnimationFrames[WINDOW_MAPGEN_PAGE_COUNT] = {
        1,
        1,
        1,
        1,
    };
    static constexpr int32_t TabAnimationLoops[WINDOW_MAPGEN_PAGE_COUNT] = {
        16,
        16,
        16,
        0,
    };
    // clang-format on

    constexpr int32_t BASESIZE_MIN = 0;
    constexpr int32_t BASESIZE_MAX = 60;
    constexpr int32_t WATERLEVEL_MIN = 0;
    constexpr int32_t WATERLEVEL_MAX = 54;
    constexpr int32_t MAX_SMOOTH_ITERATIONS = 20;

    enum class ResizeDirection
    {
        Both,
        X,
        Y,
    };

    static void HeightmapLoadsaveCallback(int32_t result, const utf8* path);

    class MapGenWindow final : public Window
    {
    private:
        TileCoordsXY _mapSize{ 150, 150 };
        ResizeDirection _resizeDirection{ ResizeDirection::Both };
        bool _mapWidthAndHeightLinked{ true };
        int32_t _baseHeight = 12;
        int32_t _waterLevel = 6;
        int32_t _floorTexture = 0;
        int32_t _wallTexture = 0;
        bool _randomTerrain = true;
        int32_t _placeTrees = 1;

        int32_t _simplex_low = 6;
        int32_t _simplex_high = 10;
        int32_t _simplex_base_freq = 60;
        int32_t _simplex_octaves = 4;

        bool _heightmapLoaded = false;
        bool _heightmapSmoothMap = false;
        int32_t _heightmapSmoothStrength = 1;
        bool _heightmapNormalize = false;
        bool _heightmapSmoothTiles = true;
        int32_t _heightmapLow = 2;
        int32_t _heightmapHigh = 70;

        void SetPage(int32_t newPage)
        {
            page = newPage;
            frame_no = 0;
            RemoveViewport();

            hold_down_widgets = HoldDownWidgets[newPage];
            widgets = PageWidgets[newPage];
            disabled_widgets = PageDisabledWidgets[newPage];
            pressed_widgets = PressedWidgets[newPage];

            // Enable heightmap widgets if one is loaded
            if (newPage == WINDOW_MAPGEN_PAGE_HEIGHTMAP && _heightmapLoaded)
            {
                SetWidgetEnabled(WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_STRENGTH, _heightmapSmoothMap);
                SetWidgetEnabled(WIDX_HEIGHTMAP_STRENGTH_UP, _heightmapSmoothMap);
                SetWidgetEnabled(WIDX_HEIGHTMAP_STRENGTH_DOWN, _heightmapSmoothMap);
                SetWidgetEnabled(WIDX_HEIGHTMAP_NORMALIZE, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_SMOOTH_TILES, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_HIGH, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_HIGH_UP, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_HIGH_DOWN, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_LOW, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_LOW_UP, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_LOW_DOWN, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_WATER_LEVEL, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_WATER_LEVEL_UP, true);
                SetWidgetEnabled(WIDX_HEIGHTMAP_WATER_LEVEL_DOWN, true);
            }

            InitScrollWidgets();
            Invalidate();
        }

        void SetPressedTab()
        {
            int32_t i;
            for (i = 0; i < WINDOW_MAPGEN_PAGE_COUNT; i++)
                pressed_widgets &= ~(1 << (WIDX_TAB_1 + i));
            pressed_widgets |= 1LL << (WIDX_TAB_1 + page);
        }

        void DrawTabImage(DrawPixelInfo& dpi, int32_t newPage, int32_t spriteIndex)
        {
            WidgetIndex widgetIndex = WIDX_TAB_1 + newPage;

            if (!WidgetIsDisabled(*this, widgetIndex))
            {
                if (page == newPage)
                {
                    int32_t frame = frame_no / TabAnimationDivisor[page];
                    spriteIndex += (frame % TabAnimationFrames[page]);
                }

                GfxDrawSprite(
                    dpi, ImageId(spriteIndex),
                    windowPos + ScreenCoordsXY{ widgets[widgetIndex].left, widgets[widgetIndex].top });
            }
        }

        void DrawTabImages(DrawPixelInfo& dpi)
        {
            DrawTabImage(dpi, WINDOW_MAPGEN_PAGE_BASE, SPR_G2_TAB_LAND);
            DrawTabImage(dpi, WINDOW_MAPGEN_PAGE_RANDOM, SPR_G2_TAB_TREE);
            DrawTabImage(dpi, WINDOW_MAPGEN_PAGE_SIMPLEX, SPR_G2_TAB_PENCIL);
            DrawTabImage(dpi, WINDOW_MAPGEN_PAGE_HEIGHTMAP, SPR_TAB_GRAPH_0);
        }

        void ChangeMapSize(int32_t sizeOffset)
        {
            if (_mapWidthAndHeightLinked)
                _resizeDirection = ResizeDirection::Both;

            if (_resizeDirection != ResizeDirection::X)
                _mapSize.y = std::clamp(
                    _mapSize.y + sizeOffset, static_cast<int>(kMinimumMapSizeTechnical),
                    static_cast<int>(kMaximumMapSizeTechnical));
            if (_resizeDirection != ResizeDirection::Y)
                _mapSize.x = std::clamp(
                    _mapSize.x + sizeOffset, static_cast<int>(kMinimumMapSizeTechnical),
                    static_cast<int>(kMaximumMapSizeTechnical));
        }

        void InputMapSize(WidgetIndex callingWidget, int32_t currentValue)
        {
            Formatter ft;
            ft.Add<int16_t>(kMinimumMapSizePractical);
            ft.Add<int16_t>(kMaximumMapSizePractical);

            // Practical map size is 2 lower than the technical map size
            currentValue -= 2;
            WindowTextInputOpen(
                this, callingWidget, STR_MAP_SIZE_2, STR_ENTER_MAP_SIZE, ft, STR_FORMAT_INTEGER, currentValue, 4);
        }

        void SharedMouseUp(WidgetIndex widgetIndex)
        {
            switch (widgetIndex)
            {
                case WIDX_CLOSE:
                    Close();
                    break;
                case WIDX_TAB_1:
                case WIDX_TAB_2:
                case WIDX_TAB_3:
                case WIDX_TAB_4:
                    SetPage(widgetIndex - WIDX_TAB_1);
                    break;
            }
        }

#pragma region Base page

        void BaseMouseUp(WidgetIndex widgetIndex)
        {
            SharedMouseUp(widgetIndex);

            MapGenSettings mapgenSettings;
            Formatter ft;
            switch (widgetIndex)
            {
                case WIDX_MAP_GENERATE:
                    mapgenSettings.mapSize = _mapSize;
                    mapgenSettings.height = _baseHeight + 2;
                    mapgenSettings.water_level = _waterLevel + 2;
                    mapgenSettings.floor = _floorTexture;
                    mapgenSettings.wall = _wallTexture;

                    MapGenGenerateBlank(&mapgenSettings);
                    GfxInvalidateScreen();
                    break;
                case WIDX_MAP_SIZE_Y:
                    _resizeDirection = ResizeDirection::Y;
                    InputMapSize(WIDX_MAP_SIZE_Y, _mapSize.y);
                    break;
                case WIDX_MAP_SIZE_X:
                    _resizeDirection = ResizeDirection::X;
                    InputMapSize(WIDX_MAP_SIZE_X, _mapSize.x);
                    break;
                case WIDX_MAP_SIZE_LINK:
                    _mapWidthAndHeightLinked = !_mapWidthAndHeightLinked;
                    break;
                case WIDX_BASE_HEIGHT:
                    ft.Add<int16_t>((BASESIZE_MIN - 12) / 2);
                    ft.Add<int16_t>((BASESIZE_MAX - 12) / 2);
                    WindowTextInputOpen(
                        this, WIDX_BASE_HEIGHT, STR_BASE_HEIGHT, STR_ENTER_BASE_HEIGHT, ft, STR_FORMAT_INTEGER,
                        (_baseHeight - 12) / 2, 3);
                    break;
                case WIDX_WATER_LEVEL:
                    ft.Add<int16_t>((WATERLEVEL_MIN - 12) / 2);
                    ft.Add<int16_t>((WATERLEVEL_MAX - 12) / 2);
                    WindowTextInputOpen(
                        this, WIDX_WATER_LEVEL, STR_WATER_LEVEL, STR_ENTER_WATER_LEVEL, ft, STR_FORMAT_INTEGER,
                        (_waterLevel - 12) / 2, 3);
                    break;
            }
        }

        void BaseMouseDown(WidgetIndex widgetIndex, Widget* widget)
        {
            switch (widgetIndex)
            {
                case WIDX_MAP_SIZE_Y_UP:
                    _resizeDirection = ResizeDirection::Y;
                    ChangeMapSize(+1);
                    Invalidate();
                    break;
                case WIDX_MAP_SIZE_Y_DOWN:
                    _resizeDirection = ResizeDirection::Y;
                    ChangeMapSize(-1);
                    Invalidate();
                    break;
                case WIDX_MAP_SIZE_X_UP:
                    _resizeDirection = ResizeDirection::X;
                    ChangeMapSize(+1);
                    Invalidate();
                    break;
                case WIDX_MAP_SIZE_X_DOWN:
                    _resizeDirection = ResizeDirection::X;
                    ChangeMapSize(-1);
                    Invalidate();
                    break;
                case WIDX_BASE_HEIGHT_UP:
                    _baseHeight = std::min(_baseHeight + 2, BASESIZE_MAX);
                    Invalidate();
                    break;
                case WIDX_BASE_HEIGHT_DOWN:
                    _baseHeight = std::max(_baseHeight - 2, BASESIZE_MIN);
                    Invalidate();
                    break;
                case WIDX_WATER_LEVEL_UP:
                    _waterLevel = std::min(_waterLevel + 2, WATERLEVEL_MAX);
                    Invalidate();
                    break;
                case WIDX_WATER_LEVEL_DOWN:
                    _waterLevel = std::max(_waterLevel - 2, WATERLEVEL_MIN);
                    Invalidate();
                    break;
                case WIDX_FLOOR_TEXTURE:
                    LandTool::ShowSurfaceStyleDropdown(this, widget, _floorTexture);
                    break;
                case WIDX_WALL_TEXTURE:
                    LandTool::ShowEdgeStyleDropdown(this, widget, _wallTexture);
                    break;
            }
        }

        void BaseDropdown(WidgetIndex widgetIndex, int32_t dropdownIndex)
        {
            int32_t type;

            switch (widgetIndex)
            {
                case WIDX_FLOOR_TEXTURE:
                    if (dropdownIndex == -1)
                        dropdownIndex = gDropdownHighlightedIndex;

                    type = (dropdownIndex == -1) ? _floorTexture : dropdownIndex;

                    if (gLandToolTerrainSurface == type)
                    {
                        gLandToolTerrainSurface = OBJECT_ENTRY_INDEX_NULL;
                    }
                    else
                    {
                        gLandToolTerrainSurface = type;
                        _floorTexture = type;
                    }
                    Invalidate();
                    break;
                case WIDX_WALL_TEXTURE:
                    if (dropdownIndex == -1)
                        dropdownIndex = gDropdownHighlightedIndex;

                    type = (dropdownIndex == -1) ? _wallTexture : dropdownIndex;

                    if (gLandToolTerrainEdge == type)
                    {
                        gLandToolTerrainEdge = OBJECT_ENTRY_INDEX_NULL;
                    }
                    else
                    {
                        gLandToolTerrainEdge = type;
                        _wallTexture = type;
                    }
                    Invalidate();
                    break;
            }
        }

        void BaseUpdate()
        {
            // Tab animation
            if (++frame_no >= TabAnimationLoops[page])
                frame_no = 0;
            InvalidateWidget(WIDX_TAB_1);
        }

        void TextInput(WidgetIndex widgetIndex, std::string_view text)
        {
            int32_t value;
            char* end;

            const auto strText = u8string(text);
            value = strtol(strText.c_str(), &end, 10);

            if (*end != '\0')
            {
                return;
            }

            switch (widgetIndex)
            {
                case WIDX_MAP_SIZE_Y:
                case WIDX_MAP_SIZE_X:
                case WIDX_SIMPLEX_MAP_SIZE_Y:
                case WIDX_SIMPLEX_MAP_SIZE_X:
                    // The practical size is 2 lower than the technical size
                    value += 2;
                    if (_resizeDirection == ResizeDirection::Y || _mapWidthAndHeightLinked)
                        _mapSize.y = value;
                    if (_resizeDirection == ResizeDirection::X || _mapWidthAndHeightLinked)
                        _mapSize.x = value;
                    break;
                case WIDX_BASE_HEIGHT:
                    _baseHeight = std::clamp((value * 2) + 12, BASESIZE_MIN, BASESIZE_MAX);
                    break;
                case WIDX_WATER_LEVEL:
                    _waterLevel = std::clamp((value * 2) + 12, WATERLEVEL_MIN, WATERLEVEL_MAX);
                    break;
            }

            Invalidate();
        }

        void BasePrepareDraw()
        {
            if (widgets != PageWidgets[WINDOW_MAPGEN_PAGE_BASE])
            {
                widgets = PageWidgets[WINDOW_MAPGEN_PAGE_BASE];
                InitScrollWidgets();
            }

            // Only allow linking the map size when X and Y are the same
            SetWidgetPressed(WIDX_MAP_SIZE_LINK, _mapWidthAndHeightLinked);
            SetWidgetDisabled(WIDX_MAP_SIZE_LINK, _mapSize.x != _mapSize.y);

            SetPressedTab();

            // Push width (Y) and height (X) to the common formatter arguments for the map size spinners to use
            auto ft = Formatter::Common();
            ft.Add<uint16_t>(_mapSize.y - 2);
            ft.Add<uint16_t>(_mapSize.x - 2);
        }

        void DrawDropdownButton(DrawPixelInfo& dpi, WidgetIndex widgetIndex, ImageId image)
        {
            const auto& widget = widgets[widgetIndex];
            ScreenCoordsXY pos = { windowPos.x + widget.left, windowPos.y + widget.top };
            if (IsWidgetDisabled(widgetIndex))
            {
                // Draw greyed out (light border bottom right shadow)
                auto colour = colours[widget.colour];
                colour = ColourMapA[NOT_TRANSLUCENT(colour)].lighter;
                GfxDrawSpriteSolid(dpi, image, pos + ScreenCoordsXY{ 1, 1 }, colour);

                // Draw greyed out (dark)
                colour = colours[widget.colour];
                colour = ColourMapA[NOT_TRANSLUCENT(colour)].mid_light;
                GfxDrawSpriteSolid(dpi, image, pos, colour);
            }
            else
            {
                GfxDrawSprite(dpi, image, pos);
            }
        }

        void DrawDropdownButtons(DrawPixelInfo& dpi, WidgetIndex floorWidgetIndex, WidgetIndex edgeWidgetIndex)
        {
            auto& objManager = GetContext()->GetObjectManager();
            const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
                objManager.GetLoadedObject(ObjectType::TerrainSurface, _floorTexture));
            ImageId surfaceImage;
            if (surfaceObj != nullptr)
            {
                surfaceImage = ImageId(surfaceObj->IconImageId);
                if (surfaceObj->Colour != TerrainSurfaceObject::kNoValue)
                {
                    surfaceImage = surfaceImage.WithPrimary(surfaceObj->Colour);
                }
            }

            ImageId edgeImage;
            const auto edgeObj = static_cast<TerrainEdgeObject*>(
                objManager.GetLoadedObject(ObjectType::TerrainEdge, _wallTexture));
            if (edgeObj != nullptr)
            {
                edgeImage = ImageId(edgeObj->IconImageId);
            }

            DrawDropdownButton(dpi, floorWidgetIndex, surfaceImage);
            DrawDropdownButton(dpi, edgeWidgetIndex, edgeImage);
        }

        void BaseDraw(DrawPixelInfo& dpi)
        {
            DrawWidgets(dpi);
            DrawTabImages(dpi);
            DrawDropdownButtons(dpi, WIDX_FLOOR_TEXTURE, WIDX_WALL_TEXTURE);

            const auto textColour = colours[1];

            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 4, widgets[WIDX_MAP_SIZE_Y].top + 1 }, STR_MAP_SIZE, {}, { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 4, widgets[WIDX_BASE_HEIGHT].top + 1 }, STR_BASE_HEIGHT_LABEL, {},
                { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 4, widgets[WIDX_WATER_LEVEL].top + 1 }, STR_WATER_LEVEL_LABEL, {},
                { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 4, widgets[WIDX_FLOOR_TEXTURE].top + 1 }, STR_TERRAIN_LABEL, {},
                { textColour });

            auto ft = Formatter();
            ft.Add<uint16_t>((_baseHeight - 12) / 2);
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_BASE_HEIGHT].left + 1, widgets[WIDX_BASE_HEIGHT].top + 1 },
                STR_COMMA16, ft, { colours[1] });

            ft = Formatter();
            ft.Add<uint16_t>((_waterLevel - 12) / 2);
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_WATER_LEVEL].left + 1, widgets[WIDX_WATER_LEVEL].top + 1 },
                STR_COMMA16, ft, { colours[1] });
        }

#pragma endregion

#pragma region Random page

        void RandomMouseUp(WidgetIndex widgetIndex)
        {
            SharedMouseUp(widgetIndex);

            MapGenSettings mapgenSettings;

            switch (widgetIndex)
            {
                case WIDX_RANDOM_GENERATE:
                    mapgenSettings.mapSize = _mapSize;
                    mapgenSettings.height = _baseHeight + 2;
                    mapgenSettings.water_level = _waterLevel + 2;
                    mapgenSettings.floor = _randomTerrain ? -1 : _floorTexture;
                    mapgenSettings.wall = _randomTerrain ? -1 : _wallTexture;
                    mapgenSettings.trees = _placeTrees;

                    mapgenSettings.simplex_low = UtilRand() % 4;
                    mapgenSettings.simplex_high = 12 + (UtilRand() % (32 - 12));
                    mapgenSettings.simplex_base_freq = 1.75f;
                    mapgenSettings.simplex_octaves = 6;

                    MapGenGenerate(&mapgenSettings);
                    GfxInvalidateScreen();
                    break;
                case WIDX_RANDOM_TERRAIN:
                    _randomTerrain = !_randomTerrain;
                    break;
                case WIDX_RANDOM_PLACE_TREES:
                    _placeTrees ^= 1;
                    break;
            }
        }

        void RandomUpdate()
        {
            // Tab animation
            if (++frame_no >= TabAnimationLoops[page])
                frame_no = 0;
            InvalidateWidget(WIDX_TAB_2);
        }

        void RandomPrepareDraw()
        {
            if (widgets != PageWidgets[WINDOW_MAPGEN_PAGE_RANDOM])
            {
                widgets = PageWidgets[WINDOW_MAPGEN_PAGE_RANDOM];
                InitScrollWidgets();
            }

            pressed_widgets = 0;
            if (_randomTerrain)
                pressed_widgets |= 1uLL << WIDX_RANDOM_TERRAIN;
            if (_placeTrees)
                pressed_widgets |= 1uLL << WIDX_RANDOM_PLACE_TREES;

            SetPressedTab();
        }

        void RandomDraw(DrawPixelInfo& dpi)
        {
            DrawWidgets(dpi);
            DrawTabImages(dpi);
        }

#pragma endregion

#pragma region Simplex page

        void SimplexMouseUp(WidgetIndex widgetIndex)
        {
            SharedMouseUp(widgetIndex);

            MapGenSettings mapgenSettings;

            switch (widgetIndex)
            {
                case WIDX_SIMPLEX_MAP_SIZE_Y:
                    _resizeDirection = ResizeDirection::Y;
                    InputMapSize(WIDX_SIMPLEX_MAP_SIZE_Y, _mapSize.y);
                    break;
                case WIDX_SIMPLEX_MAP_SIZE_X:
                    _resizeDirection = ResizeDirection::X;
                    InputMapSize(WIDX_SIMPLEX_MAP_SIZE_X, _mapSize.x);
                    break;
                case WIDX_SIMPLEX_MAP_SIZE_LINK:
                    _mapWidthAndHeightLinked = !_mapWidthAndHeightLinked;
                    break;
                case WIDX_SIMPLEX_GENERATE:
                    mapgenSettings.mapSize = _mapSize;

                    mapgenSettings.height = _baseHeight;
                    mapgenSettings.water_level = _waterLevel + kMinimumWaterHeight;
                    mapgenSettings.floor = _randomTerrain ? -1 : _floorTexture;
                    mapgenSettings.wall = _randomTerrain ? -1 : _wallTexture;
                    mapgenSettings.trees = _placeTrees;

                    mapgenSettings.simplex_low = _simplex_low;
                    mapgenSettings.simplex_high = _simplex_high;
                    mapgenSettings.simplex_base_freq = (static_cast<float>(_simplex_base_freq)) / 100.00f;
                    mapgenSettings.simplex_octaves = _simplex_octaves;

                    MapGenGenerate(&mapgenSettings);
                    GfxInvalidateScreen();
                    break;
            }
        }

        void SimplexMouseDown(WidgetIndex widgetIndex, Widget* widget)
        {
            switch (widgetIndex)
            {
                case WIDX_SIMPLEX_LOW_UP:
                    _simplex_low = std::min(_simplex_low + 1, 24);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_LOW_DOWN:
                    _simplex_low = std::max(_simplex_low - 1, 0);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_HIGH_UP:
                    _simplex_high = std::min(_simplex_high + 1, 36);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_HIGH_DOWN:
                    _simplex_high = std::max(_simplex_high - 1, 0);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_BASE_FREQ_UP:
                    _simplex_base_freq = std::min(_simplex_base_freq + 5, 1000);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_BASE_FREQ_DOWN:
                    _simplex_base_freq = std::max(_simplex_base_freq - 5, 0);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_OCTAVES_UP:
                    _simplex_octaves = std::min(_simplex_octaves + 1, 10);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_OCTAVES_DOWN:
                    _simplex_octaves = std::max(_simplex_octaves - 1, 1);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_MAP_SIZE_Y_UP:
                    _resizeDirection = ResizeDirection::Y;
                    ChangeMapSize(+1);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_MAP_SIZE_Y_DOWN:
                    _resizeDirection = ResizeDirection::Y;
                    ChangeMapSize(-1);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_MAP_SIZE_X_UP:
                    _resizeDirection = ResizeDirection::X;
                    ChangeMapSize(+1);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_MAP_SIZE_X_DOWN:
                    _resizeDirection = ResizeDirection::X;
                    ChangeMapSize(-1);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_WATER_LEVEL_UP:
                    _waterLevel = std::min(_waterLevel + kMinimumWaterHeight, kMinimumWaterHeight + kMaximumWaterHeight);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_WATER_LEVEL_DOWN:
                    _waterLevel = std::max(_waterLevel - kMinimumWaterHeight, 0);
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX:
                    _randomTerrain = !_randomTerrain;
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_FLOOR_TEXTURE:
                    LandTool::ShowSurfaceStyleDropdown(this, widget, _floorTexture);
                    break;
                case WIDX_SIMPLEX_WALL_TEXTURE:
                    LandTool::ShowEdgeStyleDropdown(this, widget, _wallTexture);
                    break;
                case WIDX_SIMPLEX_PLACE_TREES_CHECKBOX:
                    _placeTrees ^= 1;
                    Invalidate();
                    break;
            }
        }

        void SimplexDropdown(WidgetIndex widgetIndex, int32_t dropdownIndex)
        {
            int32_t type;

            switch (widgetIndex)
            {
                case WIDX_SIMPLEX_FLOOR_TEXTURE:
                    if (dropdownIndex == -1)
                        dropdownIndex = gDropdownHighlightedIndex;

                    type = (dropdownIndex == -1) ? _floorTexture : dropdownIndex;

                    if (gLandToolTerrainSurface == type)
                    {
                        gLandToolTerrainSurface = OBJECT_ENTRY_INDEX_NULL;
                    }
                    else
                    {
                        gLandToolTerrainSurface = type;
                        _floorTexture = type;
                    }
                    Invalidate();
                    break;
                case WIDX_SIMPLEX_WALL_TEXTURE:
                    if (dropdownIndex == -1)
                        dropdownIndex = gDropdownHighlightedIndex;

                    type = (dropdownIndex == -1) ? _wallTexture : dropdownIndex;

                    if (gLandToolTerrainEdge == type)
                    {
                        gLandToolTerrainEdge = OBJECT_ENTRY_INDEX_NULL;
                    }
                    else
                    {
                        gLandToolTerrainEdge = type;
                        _wallTexture = type;
                    }
                    Invalidate();
                    break;
            }
        }

        void SimplexUpdate()
        {
            // Tab animation
            if (++frame_no >= TabAnimationLoops[page])
                frame_no = 0;
            InvalidateWidget(WIDX_TAB_3);
        }

        void SimplexPrepareDraw()
        {
            if (widgets != PageWidgets[WINDOW_MAPGEN_PAGE_SIMPLEX])
            {
                widgets = PageWidgets[WINDOW_MAPGEN_PAGE_SIMPLEX];
                InitScrollWidgets();
            }

            // Only allow linking the map size when X and Y are the same
            SetWidgetPressed(WIDX_SIMPLEX_MAP_SIZE_LINK, _mapWidthAndHeightLinked);
            SetWidgetDisabled(WIDX_SIMPLEX_MAP_SIZE_LINK, _mapSize.x != _mapSize.y);

            SetCheckboxValue(WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX, _randomTerrain != 0);
            SetCheckboxValue(WIDX_SIMPLEX_PLACE_TREES_CHECKBOX, _placeTrees != 0);

            // Only allow floor and wall texture options if random terrain is disabled
            if (!_randomTerrain)
            {
                SetWidgetEnabled(WIDX_SIMPLEX_FLOOR_TEXTURE, true);
                SetWidgetEnabled(WIDX_SIMPLEX_WALL_TEXTURE, true);
            }
            else
            {
                SetWidgetEnabled(WIDX_SIMPLEX_FLOOR_TEXTURE, false);
                SetWidgetEnabled(WIDX_SIMPLEX_WALL_TEXTURE, false);
            }

            SetPressedTab();

            // Push width (Y) and height (X) to the common formatter arguments for the map size spinners to use
            auto ft = Formatter::Common();
            ft.Add<uint16_t>(_mapSize.y - 2);
            ft.Add<uint16_t>(_mapSize.x - 2);
        }

        void SimplexDraw(DrawPixelInfo& dpi)
        {
            DrawWidgets(dpi);
            DrawTabImages(dpi);
            DrawDropdownButtons(dpi, WIDX_SIMPLEX_FLOOR_TEXTURE, WIDX_SIMPLEX_WALL_TEXTURE);

            const uint8_t textColour = colours[1];

            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_LOW].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_LOW_, {},
                { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_HIGH].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_HIGH, {},
                { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_BASE_FREQ].top + 1 },
                STR_MAPGEN_SIMPLEX_NOISE_BASE_FREQUENCY, {}, { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_OCTAVES].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_OCTAVES,
                {}, { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_MAP_SIZE_Y].top + 1 }, STR_MAP_SIZE, {},
                { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_WATER_LEVEL].top + 1 }, STR_WATER_LEVEL_LABEL, {},
                { textColour });

            auto ft = Formatter();
            ft.Add<uint16_t>(_simplex_low);
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_SIMPLEX_LOW].left + 1, widgets[WIDX_SIMPLEX_LOW].top + 1 },
                STR_COMMA16, ft, { textColour });
            ft = Formatter();
            ft.Add<uint16_t>(_simplex_high);
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_SIMPLEX_HIGH].left + 1, widgets[WIDX_SIMPLEX_HIGH].top + 1 },
                STR_COMMA16, ft, { textColour });
            ft = Formatter();
            ft.Add<uint16_t>(_simplex_base_freq);
            DrawTextBasic(
                dpi,
                windowPos + ScreenCoordsXY{ widgets[WIDX_SIMPLEX_BASE_FREQ].left + 1, widgets[WIDX_SIMPLEX_BASE_FREQ].top + 1 },
                STR_WINDOW_COLOUR_2_COMMA2DP32, ft, { textColour });
            ft = Formatter();
            ft.Add<uint16_t>(_simplex_octaves);
            DrawTextBasic(
                dpi,
                windowPos + ScreenCoordsXY{ widgets[WIDX_SIMPLEX_OCTAVES].left + 1, widgets[WIDX_SIMPLEX_OCTAVES].top + 1 },
                STR_COMMA16, ft, { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX].top + 1 }, STR_TERRAIN_LABEL,
                {}, { textColour });
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_SIMPLEX_PLACE_TREES_CHECKBOX].top + 1 },
                STR_MAPGEN_OPTION_PLACE_TREES, {}, { textColour });

            ft = Formatter();
            ft.Add<uint16_t>((_waterLevel - 12) / 2);
            DrawTextBasic(
                dpi,
                windowPos
                    + ScreenCoordsXY{ widgets[WIDX_SIMPLEX_WATER_LEVEL].left + 1, widgets[WIDX_SIMPLEX_WATER_LEVEL].top + 1 },
                STR_COMMA16, ft, { textColour });
        }

#pragma endregion

#pragma region Heightmap page

        void HeightmapMouseDown(WidgetIndex widgetIndex, Widget* widget)
        {
            switch (widgetIndex)
            {
                case WIDX_HEIGHTMAP_STRENGTH_UP:
                    _heightmapSmoothStrength = std::min(_heightmapSmoothStrength + 1, MAX_SMOOTH_ITERATIONS);
                    InvalidateWidget(WIDX_HEIGHTMAP_STRENGTH);
                    break;
                case WIDX_HEIGHTMAP_STRENGTH_DOWN:
                    _heightmapSmoothStrength = std::max(_heightmapSmoothStrength - 1, 1);
                    InvalidateWidget(WIDX_HEIGHTMAP_STRENGTH);
                    break;
                case WIDX_HEIGHTMAP_LOW_UP:
                    _heightmapLow = std::min(_heightmapLow + 1, kMaximumWaterHeight - 1);
                    _heightmapHigh = std::max(_heightmapHigh, _heightmapLow + 1);
                    InvalidateWidget(WIDX_HEIGHTMAP_LOW);
                    break;
                case WIDX_HEIGHTMAP_LOW_DOWN:
                    _heightmapLow = std::max(_heightmapLow - 1, 2);
                    InvalidateWidget(WIDX_HEIGHTMAP_LOW);
                    break;
                case WIDX_HEIGHTMAP_HIGH_UP:
                    _heightmapHigh = std::min<int32_t>(_heightmapHigh + 1, kMaximumWaterHeight);
                    InvalidateWidget(WIDX_HEIGHTMAP_HIGH);
                    break;
                case WIDX_HEIGHTMAP_HIGH_DOWN:
                    _heightmapHigh = std::max(_heightmapHigh - 1, 2 + 1);
                    _heightmapLow = std::min(_heightmapLow, _heightmapHigh - 1);
                    InvalidateWidget(WIDX_HEIGHTMAP_HIGH);
                    break;
                case WIDX_HEIGHTMAP_WATER_LEVEL_UP:
                    _waterLevel = std::min(_waterLevel + kMinimumWaterHeight, kMinimumWaterHeight + kMaximumWaterHeight);
                    InvalidateWidget(WIDX_HEIGHTMAP_WATER_LEVEL);
                    break;
                case WIDX_HEIGHTMAP_WATER_LEVEL_DOWN:
                    _waterLevel = std::max(_waterLevel - kMinimumWaterHeight, 0);
                    InvalidateWidget(WIDX_HEIGHTMAP_WATER_LEVEL);
                    break;
            }
        }

        void HeightmapGenerateMap()
        {
            MapGenSettings mapgenSettings;
            mapgenSettings.water_level = _waterLevel;
            mapgenSettings.smooth = _heightmapSmoothTiles;
            mapgenSettings.smooth_height_map = _heightmapSmoothMap;
            mapgenSettings.smooth_strength = _heightmapSmoothStrength;
            mapgenSettings.normalize_height = _heightmapNormalize;
            mapgenSettings.simplex_low = _heightmapLow;
            mapgenSettings.simplex_high = _heightmapHigh;
            MapGenGenerateFromHeightmap(&mapgenSettings);
            GfxInvalidateScreen();
        }

        void HeightmapMouseUp(WidgetIndex widgetIndex)
        {
            SharedMouseUp(widgetIndex);

            switch (widgetIndex)
            {
                case WIDX_CLOSE:
                case WIDX_TAB_1:
                case WIDX_TAB_2:
                case WIDX_TAB_3:
                case WIDX_TAB_4:
                    return; // Only widgets that change a setting need to regenerate the map

                    // Page widgets
                case WIDX_HEIGHTMAP_SELECT:
                {
                    auto intent = Intent(WindowClass::Loadsave);
                    intent.PutExtra(INTENT_EXTRA_LOADSAVE_TYPE, LOADSAVETYPE_LOAD | LOADSAVETYPE_HEIGHTMAP);
                    intent.PutExtra(INTENT_EXTRA_CALLBACK, reinterpret_cast<void*>(HeightmapLoadsaveCallback));
                    ContextOpenIntent(&intent);
                    return;
                }
                case WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP:
                    _heightmapSmoothMap = !_heightmapSmoothMap;
                    SetCheckboxValue(WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP, _heightmapSmoothMap);
                    SetWidgetEnabled(WIDX_HEIGHTMAP_STRENGTH, _heightmapSmoothMap);
                    SetWidgetEnabled(WIDX_HEIGHTMAP_STRENGTH_UP, _heightmapSmoothMap);
                    SetWidgetEnabled(WIDX_HEIGHTMAP_STRENGTH_DOWN, _heightmapSmoothMap);
                    InvalidateWidget(WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP);
                    InvalidateWidget(WIDX_HEIGHTMAP_STRENGTH);
                    break;
                case WIDX_HEIGHTMAP_NORMALIZE:
                    _heightmapNormalize = !_heightmapNormalize;
                    SetCheckboxValue(WIDX_HEIGHTMAP_NORMALIZE, _heightmapNormalize);
                    InvalidateWidget(WIDX_HEIGHTMAP_NORMALIZE);
                    break;
                case WIDX_HEIGHTMAP_SMOOTH_TILES:
                    _heightmapSmoothTiles = !_heightmapSmoothTiles;
                    SetCheckboxValue(WIDX_HEIGHTMAP_SMOOTH_TILES, _heightmapSmoothTiles);
                    InvalidateWidget(WIDX_HEIGHTMAP_SMOOTH_TILES);
                    break;
            }

            // Always regenerate the map after one of the page widgets has been changed
            HeightmapGenerateMap();
        }

        void HeightmapPrepareDraw()
        {
            if (widgets != PageWidgets[WINDOW_MAPGEN_PAGE_HEIGHTMAP])
            {
                widgets = PageWidgets[WINDOW_MAPGEN_PAGE_HEIGHTMAP];
                InitScrollWidgets();
            }

            SetCheckboxValue(WIDX_HEIGHTMAP_SMOOTH_HEIGHTMAP, _heightmapSmoothMap);
            SetCheckboxValue(WIDX_HEIGHTMAP_NORMALIZE, _heightmapNormalize);
            SetCheckboxValue(WIDX_HEIGHTMAP_SMOOTH_TILES, _heightmapSmoothTiles);

            SetPressedTab();
        }

        void HeightmapDraw(DrawPixelInfo& dpi)
        {
            DrawWidgets(dpi);
            DrawTabImages(dpi);

            const colour_t enabledColour = colours[1];
            const colour_t disabledColour = enabledColour | COLOUR_FLAG_INSET;

            // Smooth strength label and value
            const colour_t strengthColour = _heightmapSmoothMap ? enabledColour : disabledColour;
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_HEIGHTMAP_STRENGTH].top + 1 }, STR_MAPGEN_SMOOTH_STRENGTH, {},
                { strengthColour });

            auto ft = Formatter();
            ft.Add<uint16_t>(_heightmapSmoothStrength);
            DrawTextBasic(
                dpi,
                windowPos
                    + ScreenCoordsXY{ widgets[WIDX_HEIGHTMAP_STRENGTH].left + 1, widgets[WIDX_HEIGHTMAP_STRENGTH].top + 1 },
                STR_COMMA16, ft, { strengthColour });

            // Low label and value
            const colour_t labelColour = _heightmapLoaded ? enabledColour : disabledColour;
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_HEIGHTMAP_LOW].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_LOW_, {},
                { labelColour });

            ft = Formatter();
            ft.Add<uint16_t>(_heightmapLow);
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_HEIGHTMAP_LOW].left + 1, widgets[WIDX_HEIGHTMAP_LOW].top + 1 },
                STR_COMMA16, ft, { labelColour });

            // High label and value
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_HEIGHTMAP_HIGH].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_HIGH, {},
                { labelColour });

            ft = Formatter();
            ft.Add<uint16_t>(_heightmapHigh);
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_HEIGHTMAP_HIGH].left + 1, widgets[WIDX_HEIGHTMAP_HIGH].top + 1 },
                STR_COMMA16, ft, { labelColour });

            // Water level label and value
            DrawTextBasic(
                dpi, windowPos + ScreenCoordsXY{ 5, widgets[WIDX_HEIGHTMAP_WATER_LEVEL].top + 1 }, STR_WATER_LEVEL_LABEL, {},
                { labelColour });

            ft = Formatter();
            ft.Add<uint16_t>(_waterLevel);
            DrawTextBasic(
                dpi,
                windowPos
                    + ScreenCoordsXY{ widgets[WIDX_HEIGHTMAP_WATER_LEVEL].left + 1,
                                      widgets[WIDX_HEIGHTMAP_WATER_LEVEL].top + 1 },
                STR_COMMA16, ft, { labelColour });
        }

#pragma endregion

    public:
        void OnOpen() override
        {
            number = 0;
            frame_no = 0;

            page = WINDOW_MAPGEN_PAGE_BASE;
            Invalidate();
            widgets = PageWidgets[WINDOW_MAPGEN_PAGE_BASE];
            hold_down_widgets = HoldDownWidgets[WINDOW_MAPGEN_PAGE_BASE];
            pressed_widgets = PressedWidgets[WINDOW_MAPGEN_PAGE_BASE];
            disabled_widgets = PageDisabledWidgets[WINDOW_MAPGEN_PAGE_BASE];
            InitScrollWidgets();

            _heightmapLoaded = false;
        }

        void OnClose() override
        {
            MapGenUnloadHeightmap();
        }

        void OnMouseUp(WidgetIndex widgetIndex) override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return BaseMouseUp(widgetIndex);
                case WINDOW_MAPGEN_PAGE_RANDOM:
                    return RandomMouseUp(widgetIndex);
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return SimplexMouseUp(widgetIndex);
                case WINDOW_MAPGEN_PAGE_HEIGHTMAP:
                    return HeightmapMouseUp(widgetIndex);
            }
        }

        void OnMouseDown(WidgetIndex widgetIndex) override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return BaseMouseDown(widgetIndex, &widgets[widgetIndex]);
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return SimplexMouseDown(widgetIndex, &widgets[widgetIndex]);
                case WINDOW_MAPGEN_PAGE_HEIGHTMAP:
                    return HeightmapMouseDown(widgetIndex, &widgets[widgetIndex]);
            }
        }

        void OnDropdown(WidgetIndex widgetIndex, int32_t selectedIndex) override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return BaseDropdown(widgetIndex, selectedIndex);
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return SimplexDropdown(widgetIndex, selectedIndex);
            }
        }

        void OnUpdate() override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return BaseUpdate();
                case WINDOW_MAPGEN_PAGE_RANDOM:
                    return RandomUpdate();
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return SimplexUpdate();
            }
        }

        void OnPrepareDraw() override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return BasePrepareDraw();
                case WINDOW_MAPGEN_PAGE_RANDOM:
                    return RandomPrepareDraw();
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return SimplexPrepareDraw();
                case WINDOW_MAPGEN_PAGE_HEIGHTMAP:
                    return HeightmapPrepareDraw();
            }
        }

        void OnDraw(DrawPixelInfo& dpi) override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return BaseDraw(dpi);
                case WINDOW_MAPGEN_PAGE_RANDOM:
                    return RandomDraw(dpi);
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return SimplexDraw(dpi);
                case WINDOW_MAPGEN_PAGE_HEIGHTMAP:
                    return HeightmapDraw(dpi);
            }
        }

        void OnTextInput(WidgetIndex widgetIndex, std::string_view text) override
        {
            switch (page)
            {
                case WINDOW_MAPGEN_PAGE_BASE:
                    return TextInput(widgetIndex, text);
                case WINDOW_MAPGEN_PAGE_SIMPLEX:
                    return TextInput(widgetIndex, text);
            }
        }

        void AfterLoadingHeightMap(int32_t result, const utf8* path)
        {
            if (result == MODAL_RESULT_OK)
            {
                if (!MapGenLoadHeightmap(path))
                {
                    // TODO: Display error popup
                    return;
                }

                // The window needs to be open while using the map
                _heightmapLoaded = true;
                SetPage(WINDOW_MAPGEN_PAGE_HEIGHTMAP);

                HeightmapGenerateMap();
            }
        }

        void OnResize() override
        {
            ResizeFrameWithPage();
        }
    };

    WindowBase* MapgenOpen()
    {
        return WindowFocusOrCreate<MapGenWindow>(WindowClass::Mapgen, WW, WH, WF_10 | WF_AUTO_POSITION | WF_CENTRE_SCREEN);
    }

    static void HeightmapLoadsaveCallback(int32_t result, const utf8* path)
    {
        auto* w = static_cast<MapGenWindow*>(MapgenOpen());
        w->AfterLoadingHeightMap(result, path);
    }
} // namespace OpenRCT2::Ui::Windows