/*****************************************************************************
 * 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/LandTool.h>
#include <openrct2-ui/interface/Viewport.h>
#include <openrct2-ui/interface/Widget.h>
#include <openrct2-ui/windows/Window.h>
#include <openrct2/Cheats.h>
#include <openrct2/Context.h>
#include <openrct2/Game.h>
#include <openrct2/GameState.h>
#include <openrct2/Input.h>
#include <openrct2/OpenRCT2.h>
#include <openrct2/actions/LandSetRightsAction.h>
#include <openrct2/actions/MapChangeSizeAction.h>
#include <openrct2/actions/ParkEntrancePlaceAction.h>
#include <openrct2/actions/PeepSpawnPlaceAction.h>
#include <openrct2/actions/SurfaceSetStyleAction.h>
#include <openrct2/audio/audio.h>
#include <openrct2/entity/EntityList.h>
#include <openrct2/entity/EntityRegistry.h>
#include <openrct2/entity/Staff.h>
#include <openrct2/localisation/Formatter.h>
#include <openrct2/localisation/Language.h>
#include <openrct2/object/TerrainSurfaceObject.h>
#include <openrct2/ride/RideData.h>
#include <openrct2/ride/Track.h>
#include <openrct2/ride/TrainManager.h>
#include <openrct2/ride/Vehicle.h>
#include <openrct2/world/Entrance.h>
#include <openrct2/world/Footpath.h>
#include <openrct2/world/Scenery.h>
#include <openrct2/world/Surface.h>
#include <vector>

namespace OpenRCT2::Ui::Windows
{
    static constexpr uint16_t MapColour2(uint8_t colourA, uint8_t colourB)
    {
        return (colourA << 8) | colourB;
    }
    static constexpr uint16_t MapColour(uint8_t colour)
    {
        return MapColour2(colour, colour);
    }
    static constexpr uint16_t MapColourUnowned(uint16_t colour)
    {
        return MapColour2((colour & 0xFF00) >> 8, PALETTE_INDEX_10);
    }

    constexpr int32_t MAP_WINDOW_MAP_SIZE = kMaximumMapSizeTechnical * 2;

    static constexpr StringId WINDOW_TITLE = STR_MAP_LABEL;
    static constexpr int32_t WH = 259;
    static constexpr int32_t WW = 245;

    // Some functions manipulate coordinates on the map. These are the coordinates of the pixels in the
    // minimap. In order to distinguish those from actual coordinates, we use a separate name.
    using MapCoordsXY = TileCoordsXY;

    enum
    {
        PAGE_PEEPS,
        PAGE_RIDES
    };

    enum WindowMapWidgetIdx
    {
        WIDX_BACKGROUND,
        WIDX_TITLE,
        WIDX_CLOSE,
        WIDX_RESIZE,
        WIDX_PEOPLE_TAB,
        WIDX_RIDES_TAB,
        WIDX_MAP,
        WIDX_MAP_SIZE_SPINNER_Y,
        WIDX_MAP_SIZE_SPINNER_Y_UP,
        WIDX_MAP_SIZE_SPINNER_Y_DOWN,
        WIDX_MAP_SIZE_LINK,
        WIDX_MAP_SIZE_SPINNER_X,
        WIDX_MAP_SIZE_SPINNER_X_UP,
        WIDX_MAP_SIZE_SPINNER_X_DOWN,
        WIDX_SET_LAND_RIGHTS,
        WIDX_BUILD_PARK_ENTRANCE,
        WIDX_PEOPLE_STARTING_POSITION,
        WIDX_LAND_TOOL,
        WIDX_LAND_TOOL_SMALLER,
        WIDX_LAND_TOOL_LARGER,
        WIDX_LAND_OWNED_CHECKBOX,
        WIDX_CONSTRUCTION_RIGHTS_OWNED_CHECKBOX,
        WIDX_LAND_SALE_CHECKBOX,
        WIDX_CONSTRUCTION_RIGHTS_SALE_CHECKBOX,
        WIDX_ROTATE_90,
        WIDX_MAP_GENERATOR
    };

    validate_global_widx(WC_MAP, WIDX_ROTATE_90);

    // clang-format off
static Widget window_map_widgets[] = {
    WINDOW_SHIM(WINDOW_TITLE, WW, WH),
    MakeWidget        ({  0,  43}, {245, 215}, WindowWidgetType::Resize,    WindowColour::Secondary                                                                                  ),
    MakeRemapWidget   ({  3,  17}, { 31,  27}, WindowWidgetType::ColourBtn, WindowColour::Secondary, SPR_TAB,                         STR_SHOW_PEOPLE_ON_MAP_TIP                     ),
    MakeRemapWidget   ({ 34,  17}, { 31,  27}, WindowWidgetType::ColourBtn, WindowColour::Secondary, SPR_TAB,                         STR_SHOW_RIDES_STALLS_ON_MAP_TIP               ),
    MakeWidget        ({  3,  46}, {239, 180}, WindowWidgetType::Scroll,    WindowColour::Secondary, SCROLL_BOTH                                                                     ),
    MakeSpinnerWidgets({102, 229}, { 50,  12}, WindowWidgetType::Spinner,   WindowColour::Secondary, STR_COMMA16                                                                     ), // NB: 3 widgets
    MakeWidget        ({153, 230}, { 20,  12}, WindowWidgetType::FlatBtn,   WindowColour::Secondary, ImageId(SPR_G2_LINK_CHAIN),               STR_MAINTAIN_SQUARE_MAP_TOOLTIP                ),
    MakeSpinnerWidgets({174, 229}, { 50,  12}, WindowWidgetType::Spinner,   WindowColour::Secondary, STR_POP16_COMMA16                                                               ), // NB: 3 widgets
    MakeWidget        ({  4,   1}, { 24,  24}, WindowWidgetType::FlatBtn,   WindowColour::Secondary, ImageId(SPR_BUY_LAND_RIGHTS),             STR_SELECT_PARK_OWNED_LAND_TIP                 ),
    MakeWidget        ({  4,   1}, { 24,  24}, WindowWidgetType::FlatBtn,   WindowColour::Secondary, ImageId(SPR_PARK_ENTRANCE),               STR_BUILD_PARK_ENTRANCE_TIP                    ),
    MakeWidget        ({ 28,   1}, { 24,  24}, WindowWidgetType::FlatBtn,   WindowColour::Secondary, 0xFFFFFFFF,                      STR_SET_STARTING_POSITIONS_TIP                 ),
    MakeWidget        ({  4,  17}, { 44,  32}, WindowWidgetType::ImgBtn,    WindowColour::Secondary, ImageId(SPR_LAND_TOOL_SIZE_0)                                                            ),
    MakeRemapWidget   ({  5,  18}, { 16,  16}, WindowWidgetType::TrnBtn,    WindowColour::Secondary, SPR_LAND_TOOL_DECREASE,          STR_ADJUST_SMALLER_LAND_TIP                    ),
    MakeRemapWidget   ({ 31,  32}, { 16,  16}, WindowWidgetType::TrnBtn,    WindowColour::Secondary, SPR_LAND_TOOL_INCREASE,          STR_ADJUST_LARGER_LAND_TIP                     ),
    MakeWidget        ({ 58, 197}, {184,  12}, WindowWidgetType::Checkbox,  WindowColour::Secondary, STR_LAND_OWNED,                  STR_SET_LAND_TO_BE_OWNED_TIP                   ),
    MakeWidget        ({ 58, 197}, {184,  12}, WindowWidgetType::Checkbox,  WindowColour::Secondary, STR_CONSTRUCTION_RIGHTS_OWNED,   STR_SET_CONSTRUCTION_RIGHTS_TO_BE_OWNED_TIP    ),
    MakeWidget        ({ 58, 197}, {184,  12}, WindowWidgetType::Checkbox,  WindowColour::Secondary, STR_LAND_SALE,                   STR_SET_LAND_TO_BE_AVAILABLE_TIP               ),
    MakeWidget        ({ 58, 197}, {174,  12}, WindowWidgetType::Checkbox,  WindowColour::Secondary, STR_CONSTRUCTION_RIGHTS_SALE,    STR_SET_CONSTRUCTION_RIGHTS_TO_BE_AVAILABLE_TIP),
    MakeWidget        ({218,  45}, { 24,  24}, WindowWidgetType::FlatBtn,   WindowColour::Secondary, ImageId(SPR_ROTATE_ARROW),                STR_ROTATE_OBJECTS_90                          ),
    MakeWidget        ({110, 189}, {131,  14}, WindowWidgetType::Button,    WindowColour::Secondary, STR_MAPGEN_WINDOW_TITLE,         STR_MAP_GENERATOR_TIP                          ),
    kWidgetsEnd,
};

// used in transforming viewport view coordinates to minimap coordinates
// rct2: 0x00981BBC
static constexpr ScreenCoordsXY MiniMapOffsets[] = {
    {     kMaximumMapSizeTechnical - 8,                              0 },
    { 2 * kMaximumMapSizeTechnical - 8,     kMaximumMapSizeTechnical },
    {     kMaximumMapSizeTechnical - 8, 2 * kMaximumMapSizeTechnical },
    {                              0 - 8,     kMaximumMapSizeTechnical },
};
    // clang-format on

    static constexpr StringId MapLabels[] = {
        STR_MAP_RIDE,       STR_MAP_FOOD_STALL, STR_MAP_DRINK_STALL,  STR_MAP_SOUVENIR_STALL,
        STR_MAP_INFO_KIOSK, STR_MAP_FIRST_AID,  STR_MAP_CASH_MACHINE, STR_MAP_TOILET,
    };

    static constexpr uint16_t RideKeyColours[] = {
        MapColour(PALETTE_INDEX_61),  // COLOUR_KEY_RIDE
        MapColour(PALETTE_INDEX_42),  // COLOUR_KEY_FOOD
        MapColour(PALETTE_INDEX_20),  // COLOUR_KEY_DRINK
        MapColour(PALETTE_INDEX_209), // COLOUR_KEY_SOUVENIR
        MapColour(PALETTE_INDEX_136), // COLOUR_KEY_KIOSK
        MapColour(PALETTE_INDEX_102), // COLOUR_KEY_FIRST_AID
        MapColour(PALETTE_INDEX_55),  // COLOUR_KEY_CASH_MACHINE
        MapColour(PALETTE_INDEX_161), // COLOUR_KEY_TOILETS
    };

    static constexpr uint8_t DefaultPeepMapColour = PALETTE_INDEX_20;
    static constexpr uint8_t GuestMapColour = PALETTE_INDEX_172;
    static constexpr uint8_t GuestMapColourAlternate = PALETTE_INDEX_21;
    static constexpr uint8_t StaffMapColour = PALETTE_INDEX_138;
    static constexpr uint8_t StaffMapColourAlternate = PALETTE_INDEX_10;

    static constexpr uint16_t WaterColour = MapColour(PALETTE_INDEX_195);

    static constexpr uint16_t ElementTypeMaskColour[] = {
        0xFFFF, // TILE_ELEMENT_TYPE_SURFACE
        0x0000, // TILE_ELEMENT_TYPE_PATH
        0x00FF, // TILE_ELEMENT_TYPE_TRACK
        0xFF00, // TILE_ELEMENT_TYPE_SMALL_SCENERY
        0x0000, // TILE_ELEMENT_TYPE_ENTRANCE
        0xFFFF, // TILE_ELEMENT_TYPE_WALL
        0x0000, // TILE_ELEMENT_TYPE_LARGE_SCENERY
        0xFFFF, // TILE_ELEMENT_TYPE_BANNER
    };

    static constexpr uint16_t ElementTypeAddColour[] = {
        MapColour(PALETTE_INDEX_0),                     // TILE_ELEMENT_TYPE_SURFACE
        MapColour(PALETTE_INDEX_17),                    // TILE_ELEMENT_TYPE_PATH
        MapColour2(PALETTE_INDEX_183, PALETTE_INDEX_0), // TILE_ELEMENT_TYPE_TRACK
        MapColour2(PALETTE_INDEX_0, PALETTE_INDEX_99),  // TILE_ELEMENT_TYPE_SMALL_SCENERY
        MapColour(PALETTE_INDEX_186),                   // TILE_ELEMENT_TYPE_ENTRANCE
        MapColour(PALETTE_INDEX_0),                     // TILE_ELEMENT_TYPE_WALL
        MapColour(PALETTE_INDEX_99),                    // TILE_ELEMENT_TYPE_LARGE_SCENERY
        MapColour(PALETTE_INDEX_0),                     // TILE_ELEMENT_TYPE_BANNER
    };

    class MapWindow final : public Window
    {
        uint8_t _rotation;
        uint8_t _activeTool;
        uint32_t _currentLine;
        uint16_t _landRightsToolSize;
        int32_t _firstColumnWidth;
        std::vector<uint8_t> _mapImageData;
        bool _mapWidthAndHeightLinked{ true };
        bool _recalculateScrollbars = false;
        enum class ResizeDirection
        {
            Both,
            X,
            Y,
        } _resizeDirection{ ResizeDirection::Both };

    public:
        MapWindow()
        {
            _mapImageData.resize(MAP_WINDOW_MAP_SIZE * MAP_WINDOW_MAP_SIZE);
        }

        void OnOpen() override
        {
            widgets = window_map_widgets;

            hold_down_widgets = (1uLL << WIDX_MAP_SIZE_SPINNER_Y_UP) | (1uLL << WIDX_MAP_SIZE_SPINNER_Y_DOWN)
                | (1uLL << WIDX_MAP_SIZE_SPINNER_X_UP) | (1uLL << WIDX_MAP_SIZE_SPINNER_X_DOWN)
                | (1uLL << WIDX_LAND_TOOL_LARGER) | (1uLL << WIDX_LAND_TOOL_SMALLER);

            flags |= WF_RESIZABLE;
            min_width = WW;
            max_width = 800;
            min_height = WH;
            max_height = 560;

            ResizeMap();
            InitScrollWidgets();
            CalculateTextLayout();

            _rotation = GetCurrentRotation();

            InitMap();
            gWindowSceneryRotation = 0;
            CentreMapOnViewPoint();
            FootpathSelectDefault();

            auto& gameState = GetGameState();
            _mapWidthAndHeightLinked = gameState.MapSize.x == gameState.MapSize.y;

            // Reset land rights tool size
            _landRightsToolSize = 1;
        }

        void OnClose() override
        {
            _mapImageData.clear();
            _mapImageData.shrink_to_fit();
            if ((InputTestFlag(INPUT_FLAG_TOOL_ACTIVE)) && gCurrentToolWidget.window_classification == classification
                && gCurrentToolWidget.window_number == number)
            {
                ToolCancel();
            }
        }

        void OnMouseUp(WidgetIndex widgetIndex) override
        {
            switch (widgetIndex)
            {
                case WIDX_CLOSE:
                    Close();
                    break;
                case WIDX_SET_LAND_RIGHTS:
                    Invalidate();
                    if (ToolSet(*this, widgetIndex, Tool::UpArrow))
                        break;
                    _activeTool = 2;
                    // Prevent mountain tool size.
                    _landRightsToolSize = std::max<uint16_t>(kLandToolMinimumSize, _landRightsToolSize);
                    ShowGridlines();
                    ShowLandRights();
                    ShowConstructionRights();
                    break;
                case WIDX_LAND_OWNED_CHECKBOX:
                    _activeTool ^= 2;

                    if (_activeTool & 2)
                        _activeTool &= 0xF2;

                    Invalidate();
                    break;
                case WIDX_LAND_SALE_CHECKBOX:
                    _activeTool ^= 8;

                    if (_activeTool & 8)
                        _activeTool &= 0xF8;

                    Invalidate();
                    break;
                case WIDX_CONSTRUCTION_RIGHTS_OWNED_CHECKBOX:
                    _activeTool ^= 1;

                    if (_activeTool & 1)
                        _activeTool &= 0xF1;

                    Invalidate();
                    break;
                case WIDX_CONSTRUCTION_RIGHTS_SALE_CHECKBOX:
                    _activeTool ^= 4;

                    if (_activeTool & 4)
                        _activeTool &= 0xF4;

                    Invalidate();
                    break;
                case WIDX_BUILD_PARK_ENTRANCE:
                    Invalidate();
                    if (ToolSet(*this, widgetIndex, Tool::UpArrow))
                        break;

                    gParkEntranceGhostExists = false;
                    InputSetFlag(INPUT_FLAG_6, true);

                    ShowGridlines();
                    ShowLandRights();
                    ShowConstructionRights();
                    break;
                case WIDX_ROTATE_90:
                    gWindowSceneryRotation = (gWindowSceneryRotation + 1) & 3;
                    break;
                case WIDX_PEOPLE_STARTING_POSITION:
                    if (ToolSet(*this, widgetIndex, Tool::UpArrow))
                        break;

                    ShowGridlines();
                    ShowLandRights();
                    ShowConstructionRights();
                    break;
                case WIDX_LAND_TOOL:
                    InputLandSize();
                    break;
                case WIDX_MAP_SIZE_SPINNER_Y:
                case WIDX_MAP_SIZE_SPINNER_X:
                    InputMapSize(widgetIndex);
                    break;
                case WIDX_MAP_SIZE_LINK:
                    _mapWidthAndHeightLinked = !_mapWidthAndHeightLinked;
                    break;
                case WIDX_MAP_GENERATOR:
                    ContextOpenWindow(WindowClass::Mapgen);
                    break;
                default:
                    if (widgetIndex >= WIDX_PEOPLE_TAB && widgetIndex <= WIDX_RIDES_TAB)
                    {
                        widgetIndex -= WIDX_PEOPLE_TAB;
                        if (widgetIndex == selected_tab)
                            break;

                        selected_tab = widgetIndex;
                        list_information_type = 0;
                        _recalculateScrollbars = true;
                    }
            }
        }

        void OnMouseDown(WidgetIndex widgetIndex) override
        {
            switch (widgetIndex)
            {
                case WIDX_MAP_SIZE_SPINNER_Y_UP:
                    _resizeDirection = ResizeDirection::Y;
                    IncreaseMapSize();
                    break;
                case WIDX_MAP_SIZE_SPINNER_Y_DOWN:
                    _resizeDirection = ResizeDirection::Y;
                    DecreaseMapSize();
                    break;
                case WIDX_MAP_SIZE_SPINNER_X_UP:
                    _resizeDirection = ResizeDirection::X;
                    IncreaseMapSize();
                    break;
                case WIDX_MAP_SIZE_SPINNER_X_DOWN:
                    _resizeDirection = ResizeDirection::X;
                    DecreaseMapSize();
                    break;
                case WIDX_LAND_TOOL_SMALLER:
                    // Decrement land rights tool size
                    _landRightsToolSize = std::max<uint16_t>(kLandToolMinimumSize, _landRightsToolSize - 1);

                    Invalidate();
                    break;
                case WIDX_LAND_TOOL_LARGER:
                    // Increment land rights tool size
                    _landRightsToolSize = std::min<uint16_t>(kLandToolMaximumSize, _landRightsToolSize + 1);

                    Invalidate();
                    break;
            }
        }

        void OnUpdate() override
        {
            if (GetCurrentRotation() != _rotation)
            {
                _rotation = GetCurrentRotation();
                InitMap();
                CentreMapOnViewPoint();
            }

            for (int32_t i = 0; i < 16; i++)
                SetMapPixels();

            Invalidate();

            // Update tab animations
            list_information_type++;
            switch (selected_tab)
            {
                case PAGE_PEEPS:
                    if (list_information_type >= 32)
                    {
                        list_information_type = 0;
                    }
                    break;
                case PAGE_RIDES:
                    if (list_information_type >= 64)
                    {
                        list_information_type = 0;
                    }
                    break;
            }
        }

        void OnToolUpdate(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
        {
            switch (widgetIndex)
            {
                case WIDX_SET_LAND_RIGHTS:
                    SetLandRightsToolUpdate(screenCoords);
                    break;
                case WIDX_BUILD_PARK_ENTRANCE:
                    PlaceParkEntranceToolUpdate(screenCoords);
                    break;
                case WIDX_PEOPLE_STARTING_POSITION:
                    SetPeepSpawnToolUpdate(screenCoords);
                    break;
            }
        }

        void OnToolDown(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
        {
            switch (widgetIndex)
            {
                case WIDX_BUILD_PARK_ENTRANCE:
                    PlaceParkEntranceToolDown(screenCoords);
                    break;
                case WIDX_PEOPLE_STARTING_POSITION:
                    SetPeepSpawnToolDown(screenCoords);
                    break;
            }
        }

        void OnToolDrag(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
        {
            switch (widgetIndex)
            {
                case WIDX_SET_LAND_RIGHTS:
                    if (gMapSelectFlags & MAP_SELECT_FLAG_ENABLE)
                    {
                        auto landSetRightsAction = LandSetRightsAction(
                            { gMapSelectPositionA.x, gMapSelectPositionA.y, gMapSelectPositionB.x, gMapSelectPositionB.y },
                            LandSetRightSetting::SetOwnershipWithChecks, _activeTool << 4);
                        GameActions::Execute(&landSetRightsAction);
                    }
                    break;
            }
        }

        void OnToolAbort(WidgetIndex widgetIndex) override
        {
            switch (widgetIndex)
            {
                case WIDX_SET_LAND_RIGHTS:
                    Invalidate();
                    HideGridlines();
                    HideLandRights();
                    HideConstructionRights();
                    break;
                case WIDX_BUILD_PARK_ENTRANCE:
                    ParkEntranceRemoveGhost();
                    Invalidate();
                    HideGridlines();
                    HideLandRights();
                    HideConstructionRights();
                    break;
                case WIDX_PEOPLE_STARTING_POSITION:
                    Invalidate();
                    HideGridlines();
                    HideLandRights();
                    HideConstructionRights();
                    break;
            }
        }

        void SetLandRightsToolUpdate(const ScreenCoordsXY& screenCoords)
        {
            MapInvalidateSelectionRect();
            gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;

            auto info = GetMapCoordinatesFromPos(
                screenCoords, EnumsToFlags(ViewportInteractionItem::Terrain, ViewportInteractionItem::Water));
            if (info.SpriteType == ViewportInteractionItem::None)
                return;

            auto mapCoords = info.Loc;

            gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE;
            gMapSelectType = MAP_SELECT_TYPE_FULL_LAND_RIGHTS;

            int32_t landRightsToolSize = _landRightsToolSize;
            if (landRightsToolSize == 0)
                landRightsToolSize = 1;

            int32_t size = (landRightsToolSize * 32) - 32;
            int32_t radius = (landRightsToolSize * 16) - 16;
            mapCoords.x -= radius;
            mapCoords.y -= radius;
            mapCoords = mapCoords.ToTileStart();
            gMapSelectPositionA = mapCoords;
            gMapSelectPositionB.x = mapCoords.x + size;
            gMapSelectPositionB.y = mapCoords.y + size;
            MapInvalidateSelectionRect();
        }

        CoordsXYZD PlaceParkEntranceGetMapPosition(const ScreenCoordsXY& screenCoords)
        {
            CoordsXYZD parkEntranceMapPosition{ 0, 0, 0, INVALID_DIRECTION };
            const CoordsXY mapCoords = ViewportInteractionGetTileStartAtCursor(screenCoords);
            parkEntranceMapPosition = { mapCoords.x, mapCoords.y, 0, INVALID_DIRECTION };
            if (parkEntranceMapPosition.IsNull())
                return parkEntranceMapPosition;

            auto surfaceElement = MapGetSurfaceElementAt(mapCoords);
            if (surfaceElement == nullptr)
            {
                parkEntranceMapPosition.SetNull();
                return parkEntranceMapPosition;
            }

            parkEntranceMapPosition.z = surfaceElement->GetWaterHeight();
            if (parkEntranceMapPosition.z == 0)
            {
                parkEntranceMapPosition.z = surfaceElement->GetBaseZ();
                if ((surfaceElement->GetSlope() & TILE_ELEMENT_SLOPE_ALL_CORNERS_UP) != 0)
                {
                    parkEntranceMapPosition.z += 16;
                    if (surfaceElement->GetSlope() & TILE_ELEMENT_SLOPE_DOUBLE_HEIGHT)
                    {
                        parkEntranceMapPosition.z += 16;
                    }
                }
            }
            parkEntranceMapPosition.direction = (gWindowSceneryRotation - GetCurrentRotation()) & 3;
            return parkEntranceMapPosition;
        }

        void PlaceParkEntranceToolUpdate(const ScreenCoordsXY& screenCoords)
        {
            MapInvalidateSelectionRect();
            MapInvalidateMapSelectionTiles();
            gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
            gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
            gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_CONSTRUCT;
            CoordsXYZD parkEntrancePosition = PlaceParkEntranceGetMapPosition(screenCoords);
            if (parkEntrancePosition.IsNull())
            {
                ParkEntranceRemoveGhost();
                return;
            }

            int32_t sideDirection = (parkEntrancePosition.direction + 1) & 3;
            gMapSelectionTiles.clear();
            gMapSelectionTiles.push_back({ parkEntrancePosition.x, parkEntrancePosition.y });
            gMapSelectionTiles.push_back({ parkEntrancePosition.x + CoordsDirectionDelta[sideDirection].x,
                                           parkEntrancePosition.y + CoordsDirectionDelta[sideDirection].y });
            gMapSelectionTiles.push_back({ parkEntrancePosition.x - CoordsDirectionDelta[sideDirection].x,
                                           parkEntrancePosition.y - CoordsDirectionDelta[sideDirection].y });

            gMapSelectArrowPosition = parkEntrancePosition;
            gMapSelectArrowDirection = parkEntrancePosition.direction;

            gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE_CONSTRUCT | MAP_SELECT_FLAG_ENABLE_ARROW;
            MapInvalidateMapSelectionTiles();
            if (gParkEntranceGhostExists && parkEntrancePosition == gParkEntranceGhostPosition)
            {
                return;
            }

            ParkEntranceRemoveGhost();

            auto gameAction = ParkEntrancePlaceAction(parkEntrancePosition, gFootpathSelectedId);
            gameAction.SetFlags(GAME_COMMAND_FLAG_GHOST);

            auto result = GameActions::Execute(&gameAction);
            if (result.Error == GameActions::Status::Ok)
            {
                gParkEntranceGhostPosition = parkEntrancePosition;
                gParkEntranceGhostExists = true;
            }
        }

        void PlaceParkEntranceToolDown(const ScreenCoordsXY& screenCoords)
        {
            ParkEntranceRemoveGhost();

            CoordsXYZD parkEntrancePosition = PlaceParkEntranceGetMapPosition(screenCoords);
            if (!parkEntrancePosition.IsNull())
            {
                auto gameAction = ParkEntrancePlaceAction(parkEntrancePosition, gFootpathSelectedId);
                auto result = GameActions::Execute(&gameAction);
                if (result.Error == GameActions::Status::Ok)
                {
                    Audio::Play3D(Audio::SoundId::PlaceItem, result.Position);
                }
            }
        }

        void SetPeepSpawnToolUpdate(const ScreenCoordsXY& screenCoords)
        {
            int32_t direction;
            TileElement* tileElement;
            MapInvalidateSelectionRect();
            gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
            gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
            auto mapCoords = FootpathBridgeGetInfoFromPos(screenCoords, &direction, &tileElement);
            if (mapCoords.IsNull())
                return;

            int32_t mapZ = tileElement->GetBaseZ();
            if (tileElement->GetType() == TileElementType::Surface)
            {
                if ((tileElement->AsSurface()->GetSlope() & TILE_ELEMENT_SLOPE_ALL_CORNERS_UP) != 0)
                    mapZ += 16;
                if (tileElement->AsSurface()->GetSlope() & TILE_ELEMENT_SLOPE_DOUBLE_HEIGHT)
                    mapZ += 16;
            }

            gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE;
            gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE_ARROW;
            gMapSelectType = MAP_SELECT_TYPE_FULL;
            gMapSelectPositionA = mapCoords;
            gMapSelectPositionB = mapCoords;
            gMapSelectArrowPosition = CoordsXYZ{ mapCoords, mapZ };
            gMapSelectArrowDirection = DirectionReverse(direction);
            MapInvalidateSelectionRect();
        }

        void SetPeepSpawnToolDown(const ScreenCoordsXY& screenCoords)
        {
            // Verify footpath exists at location, and retrieve coordinates
            TileElement* tileElement;
            int32_t direction;
            auto mapCoords = FootpathGetCoordinatesFromPos(screenCoords, &direction, &tileElement);
            if (mapCoords.IsNull())
                return;

            int32_t mapZ = tileElement->GetBaseZ();

            auto gameAction = PeepSpawnPlaceAction({ mapCoords, mapZ, static_cast<Direction>(direction) });
            auto result = GameActions::Execute(&gameAction);
            if (result.Error == GameActions::Status::Ok)
            {
                Audio::Play3D(Audio::SoundId::PlaceItem, result.Position);
            }
        }

        void OnTextInput(WidgetIndex widgetIndex, std::string_view text) override
        {
            if (text.empty())
                return;

            switch (widgetIndex)
            {
                case WIDX_LAND_TOOL:
                {
                    char* end;
                    std::string textStr = std::string(text);
                    int32_t size = strtol(textStr.c_str(), &end, 10);
                    if (*end == '\0')
                    {
                        size = std::clamp<uint16_t>(size, kLandToolMinimumSize, kLandToolMaximumSize);
                        _landRightsToolSize = size;
                        Invalidate();
                    }
                    break;
                }
                case WIDX_MAP_SIZE_SPINNER_Y:
                case WIDX_MAP_SIZE_SPINNER_X:
                {
                    char* end;
                    std::string textStr = std::string(text);
                    int32_t size = strtol(textStr.c_str(), &end, 10);
                    if (*end == '\0')
                    {
                        // The practical size is 2 lower than the technical size
                        size += 2;
                        size = std::clamp(
                            size, static_cast<int>(kMinimumMapSizeTechnical), static_cast<int>(kMaximumMapSizeTechnical));

                        TileCoordsXY newMapSize = GetGameState().MapSize;
                        if (_resizeDirection != ResizeDirection::X)
                            newMapSize.y = size;
                        if (_resizeDirection != ResizeDirection::Y)
                            newMapSize.x = size;

                        auto mapChangeSizeAction = MapChangeSizeAction(newMapSize);
                        GameActions::Execute(&mapChangeSizeAction);
                        Invalidate();
                    }
                    break;
                }
            }
        }

        ScreenSize OnScrollGetSize(int32_t scrollIndex) override
        {
            return ScreenSize(MAP_WINDOW_MAP_SIZE, MAP_WINDOW_MAP_SIZE);
        }

        void OnScrollMouseDown(int32_t scrollIndex, const ScreenCoordsXY& screenCoords) override
        {
            CoordsXY c = ScreenToMap(screenCoords);
            auto mapCoords = CoordsXY{ std::clamp(c.x, 0, MAXIMUM_MAP_SIZE_BIG - 1),
                                       std::clamp(c.y, 0, MAXIMUM_MAP_SIZE_BIG - 1) };
            auto mapZ = TileElementHeight(mapCoords);

            WindowBase* mainWindow = WindowGetMain();
            if (mainWindow != nullptr)
            {
                WindowScrollToLocation(*mainWindow, { mapCoords, mapZ });
            }

            if (LandToolIsActive())
            {
                // Set land terrain
                int32_t landToolSize = std::max<int32_t>(1, gLandToolSize);
                int32_t size = (landToolSize * 32) - 32;
                int32_t radius = (landToolSize * 16) - 16;

                mapCoords = (mapCoords - CoordsXY{ radius, radius }).ToTileStart();
                MapInvalidateSelectionRect();
                gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE;
                gMapSelectType = MAP_SELECT_TYPE_FULL;
                gMapSelectPositionA = mapCoords;
                gMapSelectPositionB = mapCoords + CoordsXY{ size, size };
                MapInvalidateSelectionRect();

                auto surfaceSetStyleAction = SurfaceSetStyleAction(
                    { gMapSelectPositionA.x, gMapSelectPositionA.y, gMapSelectPositionB.x, gMapSelectPositionB.y },
                    gLandToolTerrainSurface, gLandToolTerrainEdge);
                GameActions::Execute(&surfaceSetStyleAction);
            }
            else if (WidgetIsActiveTool(*this, WIDX_SET_LAND_RIGHTS))
            {
                // Set land rights
                int32_t landRightsToolSize = std::max<int32_t>(1, _landRightsToolSize);
                int32_t size = (landRightsToolSize * 32) - 32;
                int32_t radius = (landRightsToolSize * 16) - 16;
                mapCoords = (mapCoords - CoordsXY{ radius, radius }).ToTileStart();

                MapInvalidateSelectionRect();
                gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE;
                gMapSelectType = MAP_SELECT_TYPE_FULL_LAND_RIGHTS;
                gMapSelectPositionA = mapCoords;
                gMapSelectPositionB = mapCoords + CoordsXY{ size, size };
                MapInvalidateSelectionRect();

                auto landSetRightsAction = LandSetRightsAction(
                    { gMapSelectPositionA.x, gMapSelectPositionA.y, gMapSelectPositionB.x, gMapSelectPositionB.y },
                    LandSetRightSetting::SetOwnershipWithChecks, _activeTool << 4);
                GameActions::Execute(&landSetRightsAction);
            }
        }

        void OnScrollMouseDrag(int32_t scrollIndex, const ScreenCoordsXY& screenCoords) override
        {
            OnScrollMouseDown(scrollIndex, screenCoords);
        }

        void OnScrollDraw(int32_t scrollIndex, DrawPixelInfo& dpi) override
        {
            GfxClear(dpi, PALETTE_INDEX_10);

            G1Element g1temp = {};
            g1temp.offset = _mapImageData.data();
            g1temp.width = MAP_WINDOW_MAP_SIZE;
            g1temp.height = MAP_WINDOW_MAP_SIZE;
            g1temp.x_offset = -8;
            g1temp.y_offset = -8;
            GfxSetG1Element(SPR_TEMP, &g1temp);
            DrawingEngineInvalidateImage(SPR_TEMP);
            GfxDrawSprite(dpi, ImageId(SPR_TEMP), { 0, 0 });

            if (selected_tab == PAGE_PEEPS)
            {
                PaintPeepOverlay(dpi);
            }
            else
            {
                PaintTrainOverlay(dpi);
            }
            PaintHudRectangle(dpi);
        }

        void OnPrepareDraw() override
        {
            // Set the pressed widgets
            pressed_widgets = 0;
            SetWidgetPressed(WIDX_MAP_SIZE_LINK, _mapWidthAndHeightLinked);
            pressed_widgets |= (1uLL << (WIDX_PEOPLE_TAB + selected_tab));
            pressed_widgets |= (1uLL << WIDX_LAND_TOOL);

            if (_activeTool & (1 << 3))
                pressed_widgets |= (1uLL << WIDX_LAND_SALE_CHECKBOX);

            if (_activeTool & (1 << 2))
                pressed_widgets |= (1uLL << WIDX_CONSTRUCTION_RIGHTS_SALE_CHECKBOX);

            if (_activeTool & (1 << 1))
                pressed_widgets |= (1uLL << WIDX_LAND_OWNED_CHECKBOX);

            if (_activeTool & (1 << 0))
                pressed_widgets |= (1uLL << WIDX_CONSTRUCTION_RIGHTS_OWNED_CHECKBOX);

            // Set disabled widgets
            auto& gameState = GetGameState();
            SetWidgetDisabled(WIDX_MAP_SIZE_LINK, gameState.MapSize.x != gameState.MapSize.y);

            // Resize widgets to window size
            ResizeFrameWithPage();
            ResizeMap();

            widgets[WIDX_MAP_SIZE_SPINNER_Y].top = height - 15;
            widgets[WIDX_MAP_SIZE_SPINNER_Y].bottom = height - 4;
            widgets[WIDX_MAP_SIZE_SPINNER_Y_UP].top = height - 14;
            widgets[WIDX_MAP_SIZE_SPINNER_Y_UP].bottom = height - 5;
            widgets[WIDX_MAP_SIZE_SPINNER_Y_DOWN].top = height - 14;
            widgets[WIDX_MAP_SIZE_SPINNER_Y_DOWN].bottom = height - 5;
            widgets[WIDX_MAP_SIZE_LINK].top = height - 15;
            widgets[WIDX_MAP_SIZE_LINK].bottom = height - 4;
            widgets[WIDX_MAP_SIZE_SPINNER_X].top = height - 15;
            widgets[WIDX_MAP_SIZE_SPINNER_X].bottom = height - 4;
            widgets[WIDX_MAP_SIZE_SPINNER_X_UP].top = height - 14;
            widgets[WIDX_MAP_SIZE_SPINNER_X_UP].bottom = height - 5;
            widgets[WIDX_MAP_SIZE_SPINNER_X_DOWN].top = height - 14;
            widgets[WIDX_MAP_SIZE_SPINNER_X_DOWN].bottom = height - 5;

            widgets[WIDX_SET_LAND_RIGHTS].top = height - 70;
            widgets[WIDX_SET_LAND_RIGHTS].bottom = height - 70 + 23;
            widgets[WIDX_BUILD_PARK_ENTRANCE].top = height - 46;
            widgets[WIDX_BUILD_PARK_ENTRANCE].bottom = height - 46 + 23;
            widgets[WIDX_ROTATE_90].top = height - 46;
            widgets[WIDX_ROTATE_90].bottom = height - 46 + 23;
            widgets[WIDX_PEOPLE_STARTING_POSITION].top = height - 46;
            widgets[WIDX_PEOPLE_STARTING_POSITION].bottom = height - 46 + 23;

            widgets[WIDX_LAND_TOOL].top = height - 42;
            widgets[WIDX_LAND_TOOL].bottom = height - 42 + 30;
            widgets[WIDX_LAND_TOOL_SMALLER].top = height - 41;
            widgets[WIDX_LAND_TOOL_SMALLER].bottom = height - 41 + 15;
            widgets[WIDX_LAND_TOOL_LARGER].top = height - 27;
            widgets[WIDX_LAND_TOOL_LARGER].bottom = height - 27 + 15;

            widgets[WIDX_MAP_GENERATOR].top = height - 69;
            widgets[WIDX_MAP_GENERATOR].bottom = height - 69 + 13;

            // Land tool mode (4 checkboxes)
            int checkboxY = height - 55;
            for (int32_t i = WIDX_LAND_OWNED_CHECKBOX; i <= WIDX_CONSTRUCTION_RIGHTS_SALE_CHECKBOX; i++)
            {
                widgets[i].top = checkboxY;
                checkboxY += 11;
                widgets[i].bottom = checkboxY;
                checkboxY += 2;
            }

            // Disable all scenario editor related widgets
            for (int32_t i = WIDX_MAP_SIZE_SPINNER_Y; i <= WIDX_MAP_GENERATOR; i++)
            {
                widgets[i].type = WindowWidgetType::Empty;
            }

            if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode)
            {
                // scenario editor: build park entrance selected, show rotate button
                if ((InputTestFlag(INPUT_FLAG_TOOL_ACTIVE)) && gCurrentToolWidget.window_classification == WindowClass::Map
                    && gCurrentToolWidget.widget_index == WIDX_BUILD_PARK_ENTRANCE)
                {
                    widgets[WIDX_ROTATE_90].type = WindowWidgetType::FlatBtn;
                }

                // Always show set land rights button
                widgets[WIDX_SET_LAND_RIGHTS].type = WindowWidgetType::FlatBtn;

                // If any tool is active
                if ((InputTestFlag(INPUT_FLAG_TOOL_ACTIVE)) && gCurrentToolWidget.window_classification == WindowClass::Map)
                {
                    // if not in set land rights mode: show the default scenario editor buttons
                    if (gCurrentToolWidget.widget_index != WIDX_SET_LAND_RIGHTS)
                    {
                        ShowDefaultScenarioEditorButtons();
                    }
                    else
                    { // if in set land rights mode: show land tool buttons + modes
                        widgets[WIDX_LAND_TOOL].type = WindowWidgetType::ImgBtn;
                        widgets[WIDX_LAND_TOOL_SMALLER].type = WindowWidgetType::TrnBtn;
                        widgets[WIDX_LAND_TOOL_LARGER].type = WindowWidgetType::TrnBtn;

                        for (int32_t i = WIDX_LAND_OWNED_CHECKBOX; i <= WIDX_CONSTRUCTION_RIGHTS_SALE_CHECKBOX; i++)
                            widgets[i].type = WindowWidgetType::Checkbox;

                        widgets[WIDX_LAND_TOOL].image = ImageId(LandTool::SizeToSpriteIndex(_landRightsToolSize));
                    }
                }
                else
                {
                    // if no tool is active: show the default scenario editor buttons
                    ShowDefaultScenarioEditorButtons();
                }
            }
            if (_recalculateScrollbars)
            {
                WidgetScrollUpdateThumbs(*this, WIDX_MAP);
                _recalculateScrollbars = false;
            }
        }

        void OnDraw(DrawPixelInfo& dpi) override
        {
            DrawWidgets(dpi);
            DrawTabImages(dpi);

            auto screenCoords = windowPos
                + ScreenCoordsXY{ window_map_widgets[WIDX_LAND_TOOL].midX(), window_map_widgets[WIDX_LAND_TOOL].midY() };

            // Draw land tool size
            if (WidgetIsActiveTool(*this, WIDX_SET_LAND_RIGHTS) && _landRightsToolSize > kLandToolMaximumSizeWithSprite)
            {
                auto ft = Formatter();
                ft.Add<uint16_t>(_landRightsToolSize);
                DrawTextBasic(
                    dpi, screenCoords - ScreenCoordsXY{ 0, 2 }, STR_LAND_TOOL_SIZE_VALUE, ft, { TextAlignment::CENTRE });
            }
            screenCoords.y = windowPos.y + window_map_widgets[WIDX_LAND_TOOL].bottom + 5;

            // People starting position (scenario editor only)
            if (widgets[WIDX_PEOPLE_STARTING_POSITION].type != WindowWidgetType::Empty)
            {
                screenCoords = windowPos
                    + ScreenCoordsXY{ widgets[WIDX_PEOPLE_STARTING_POSITION].left + 12,
                                      widgets[WIDX_PEOPLE_STARTING_POSITION].top + 18 };
                GfxDrawSprite(dpi, ImageId(SPR_6410, COLOUR_BRIGHT_RED, COLOUR_LIGHT_BROWN), screenCoords);
            }

            if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
            {
                // Render the map legend
                if (selected_tab == PAGE_RIDES)
                {
                    screenCoords = windowPos + ScreenCoordsXY{ 4, widgets[WIDX_MAP].bottom + 2 };

                    static_assert(std::size(RideKeyColours) == std::size(MapLabels));

                    for (uint32_t i = 0; i < std::size(RideKeyColours); i++)
                    {
                        GfxFillRect(
                            dpi, { screenCoords + ScreenCoordsXY{ 0, 2 }, screenCoords + ScreenCoordsXY{ 6, 8 } },
                            RideKeyColours[i]);
                        DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ kListRowHeight, 0 }, MapLabels[i], {});
                        screenCoords.y += kListRowHeight;
                        if (i == 3)
                        {
                            screenCoords += { _firstColumnWidth, -(kListRowHeight * 4) };
                        }
                    }
                }
            }
            else if (!WidgetIsActiveTool(*this, WIDX_SET_LAND_RIGHTS))
            {
                DrawTextBasic(
                    dpi, windowPos + ScreenCoordsXY{ 4, widgets[WIDX_MAP_SIZE_SPINNER_Y].top + 1 }, STR_MAP_SIZE, {},
                    { colours[1] });
            }
        }

        void OnLanguageChange() override
        {
            CalculateTextLayout();
        }

        void ResetMap()
        {
            InitMap();
            CentreMapOnViewPoint();
        }

    private:
        void InitMap()
        {
            std::fill(_mapImageData.begin(), _mapImageData.end(), PALETTE_INDEX_10);
            _currentLine = 0;
        }

        void CentreMapOnViewPoint()
        {
            WindowBase* mainWindow = WindowGetMain();
            int16_t ax, bx, cx, dx;
            int16_t bp, di;

            if (mainWindow == nullptr || mainWindow->viewport == nullptr)
                return;

            auto offset = MiniMapOffsets[GetCurrentRotation()];

            // calculate centre view point of viewport and transform it to minimap coordinates

            cx = ((mainWindow->viewport->view_width >> 1) + mainWindow->viewport->viewPos.x) >> 5;
            dx = ((mainWindow->viewport->view_height >> 1) + mainWindow->viewport->viewPos.y) >> 4;
            cx += offset.x;
            dx += offset.y;

            // calculate width and height of minimap

            ax = widgets[WIDX_MAP].width() - 11;
            bx = widgets[WIDX_MAP].height() - 11;
            bp = ax;
            di = bx;

            ax >>= 1;
            bx >>= 1;
            cx = std::max(cx - ax, 0);
            dx = std::max(dx - bx, 0);

            bp = scrolls[0].h_right - bp;
            di = scrolls[0].v_bottom - di;

            if (bp < 0 && (bp - cx) < 0)
                cx = 0;

            if (di < 0 && (di - dx) < 0)
                dx = 0;

            scrolls[0].h_left = cx;
            scrolls[0].v_top = dx;
            WidgetScrollUpdateThumbs(*this, WIDX_MAP);
        }

        void IncreaseMapSize()
        {
            auto newMapSize = GetGameState().MapSize;
            if (IsWidgetPressed(WIDX_MAP_SIZE_LINK) || _resizeDirection == ResizeDirection::Y)
                newMapSize.y++;
            if (IsWidgetPressed(WIDX_MAP_SIZE_LINK) || _resizeDirection == ResizeDirection::X)
                newMapSize.x++;

            auto increaseMapSizeAction = MapChangeSizeAction(newMapSize);
            GameActions::Execute(&increaseMapSizeAction);
        }

        void DecreaseMapSize()
        {
            auto newMapSize = GetGameState().MapSize;
            if (IsWidgetPressed(WIDX_MAP_SIZE_LINK) || _resizeDirection == ResizeDirection::Y)
                newMapSize.y--;
            if (IsWidgetPressed(WIDX_MAP_SIZE_LINK) || _resizeDirection == ResizeDirection::X)
                newMapSize.x--;

            auto decreaseMapSizeAction = MapChangeSizeAction(newMapSize);
            GameActions::Execute(&decreaseMapSizeAction);
        }

        void SetMapPixels()
        {
            int32_t x = 0, y = 0, dx = 0, dy = 0;

            int32_t pos = (_currentLine * (MAP_WINDOW_MAP_SIZE - 1)) + kMaximumMapSizeTechnical - 1;
            auto destinationPosition = ScreenCoordsXY{ pos % MAP_WINDOW_MAP_SIZE, pos / MAP_WINDOW_MAP_SIZE };
            auto destination = _mapImageData.data() + (destinationPosition.y * MAP_WINDOW_MAP_SIZE) + destinationPosition.x;
            switch (GetCurrentRotation())
            {
                case 0:
                    x = _currentLine * COORDS_XY_STEP;
                    y = 0;
                    dx = 0;
                    dy = COORDS_XY_STEP;
                    break;
                case 1:
                    x = MAXIMUM_TILE_START_XY;
                    y = _currentLine * COORDS_XY_STEP;
                    dx = -COORDS_XY_STEP;
                    dy = 0;
                    break;
                case 2:
                    x = MAXIMUM_MAP_SIZE_BIG - ((_currentLine + 1) * COORDS_XY_STEP);
                    y = MAXIMUM_TILE_START_XY;
                    dx = 0;
                    dy = -COORDS_XY_STEP;
                    break;
                case 3:
                    x = 0;
                    y = MAXIMUM_MAP_SIZE_BIG - ((_currentLine + 1) * COORDS_XY_STEP);
                    dx = COORDS_XY_STEP;
                    dy = 0;
                    break;
            }

            for (int32_t i = 0; i < kMaximumMapSizeTechnical; i++)
            {
                if (!MapIsEdge({ x, y }))
                {
                    uint16_t colour = 0;
                    switch (selected_tab)
                    {
                        case PAGE_PEEPS:
                            colour = GetPixelColourPeep({ x, y });
                            break;
                        case PAGE_RIDES:
                            colour = GetPixelColourRide({ x, y });
                            break;
                    }
                    destination[0] = (colour >> 8) & 0xFF;
                    destination[1] = colour;
                }
                x += dx;
                y += dy;

                destinationPosition.x++;
                destinationPosition.y++;
                destination = _mapImageData.data() + (destinationPosition.y * MAP_WINDOW_MAP_SIZE) + destinationPosition.x;
            }
            _currentLine++;
            if (_currentLine >= kMaximumMapSizeTechnical)
                _currentLine = 0;
        }

        uint16_t GetPixelColourPeep(const CoordsXY& c)
        {
            auto* surfaceElement = MapGetSurfaceElementAt(c);
            if (surfaceElement == nullptr)
                return 0;

            uint16_t colour = MapColour(PALETTE_INDEX_0);
            const auto* surfaceObject = surfaceElement->GetSurfaceObject();
            if (surfaceObject != nullptr)
                colour = MapColour2(surfaceObject->MapColours[0], surfaceObject->MapColours[1]);

            if (surfaceElement->GetWaterHeight() > 0)
                colour = WaterColour;

            if (!(surfaceElement->GetOwnership() & OWNERSHIP_OWNED))
                colour = MapColourUnowned(colour);

            const int32_t maxSupportedTileElementType = static_cast<int32_t>(std::size(ElementTypeAddColour));
            auto tileElement = reinterpret_cast<TileElement*>(surfaceElement);
            while (!(tileElement++)->IsLastForTile())
            {
                if (tileElement->IsGhost())
                {
                    colour = MapColour(PALETTE_INDEX_21);
                    break;
                }

                auto tileElementType = tileElement->GetType();
                if (EnumValue(tileElementType) >= maxSupportedTileElementType)
                {
                    tileElementType = TileElementType::Surface;
                }
                colour &= ElementTypeMaskColour[EnumValue(tileElementType)];
                colour |= ElementTypeAddColour[EnumValue(tileElementType)];
            }

            return colour;
        }

        uint16_t GetPixelColourRide(const CoordsXY& c)
        {
            uint16_t colourA = 0;                           // highlight colour
            uint16_t colourB = MapColour(PALETTE_INDEX_13); // surface colour (dark grey)

            // as an improvement we could use first_element to show underground stuff?
            TileElement* tileElement = reinterpret_cast<TileElement*>(MapGetSurfaceElementAt(c));
            do
            {
                if (tileElement == nullptr)
                    break;

                if (tileElement->IsGhost())
                {
                    colourA = MapColour(PALETTE_INDEX_21);
                    break;
                }

                switch (tileElement->GetType())
                {
                    case TileElementType::Surface:
                        if (tileElement->AsSurface()->GetWaterHeight() > 0)
                            // Why is this a different water colour as above (195)?
                            colourB = MapColour(PALETTE_INDEX_194);
                        if (!(tileElement->AsSurface()->GetOwnership() & OWNERSHIP_OWNED))
                            colourB = MapColourUnowned(colourB);
                        break;
                    case TileElementType::Path:
                        colourA = MapColour(PALETTE_INDEX_14); // lighter grey
                        break;
                    case TileElementType::Entrance:
                    {
                        if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_PARK_ENTRANCE)
                            break;
                        Ride* targetRide = GetRide(tileElement->AsEntrance()->GetRideIndex());
                        if (targetRide != nullptr)
                        {
                            const auto& colourKey = targetRide->GetRideTypeDescriptor().ColourKey;
                            colourA = RideKeyColours[EnumValue(colourKey)];
                        }
                        break;
                    }
                    case TileElementType::Track:
                    {
                        Ride* targetRide = GetRide(tileElement->AsTrack()->GetRideIndex());
                        if (targetRide != nullptr)
                        {
                            const auto& colourKey = targetRide->GetRideTypeDescriptor().ColourKey;
                            colourA = RideKeyColours[EnumValue(colourKey)];
                        }

                        break;
                    }
                    default:
                        break;
                }
            } while (!(tileElement++)->IsLastForTile());

            if (colourA != 0)
                return colourA;

            return colourB;
        }

        void PaintPeepOverlay(DrawPixelInfo& dpi)
        {
            auto flashColour = GetGuestFlashColour();
            for (auto guest : EntityList<Guest>())
            {
                DrawMapPeepPixel(guest, flashColour, dpi);
            }
            flashColour = GetStaffFlashColour();
            for (auto staff : EntityList<Staff>())
            {
                DrawMapPeepPixel(staff, flashColour, dpi);
            }
        }

        void DrawMapPeepPixel(Peep* peep, const uint8_t flashColour, DrawPixelInfo& dpi)
        {
            if (peep->x == LOCATION_NULL)
                return;

            MapCoordsXY c = TransformToMapCoords({ peep->x, peep->y });
            auto leftTop = ScreenCoordsXY{ c.x, c.y };
            auto rightBottom = leftTop;
            uint8_t colour = DefaultPeepMapColour;
            if (EntityGetFlashing(peep))
            {
                colour = flashColour;
                // If flashing then map peep pixel size is increased (by moving left top downwards)
                if (flashColour != DefaultPeepMapColour)
                {
                    leftTop.x--;
                }
            }

            GfxFillRect(dpi, { leftTop, rightBottom }, colour);
        }

        static uint8_t GetGuestFlashColour()
        {
            uint8_t colour = DefaultPeepMapColour;
            if ((gWindowMapFlashingFlags & MapFlashingFlags::FlashGuests) != 0)
            {
                colour = GuestMapColour;
                if ((gWindowMapFlashingFlags & MapFlashingFlags::SwitchColour) == 0)
                    colour = GuestMapColourAlternate;
            }
            return colour;
        }

        static uint8_t GetStaffFlashColour()
        {
            uint8_t colour = DefaultPeepMapColour;
            if ((gWindowMapFlashingFlags & MapFlashingFlags::FlashStaff) != 0)
            {
                colour = StaffMapColour;
                if ((gWindowMapFlashingFlags & MapFlashingFlags::SwitchColour) == 0)
                    colour = StaffMapColourAlternate;
            }
            return colour;
        }

        void PaintTrainOverlay(DrawPixelInfo& dpi)
        {
            for (auto train : TrainManager::View())
            {
                for (Vehicle* vehicle = train; vehicle != nullptr; vehicle = GetEntity<Vehicle>(vehicle->next_vehicle_on_train))
                {
                    if (vehicle->x == LOCATION_NULL)
                        continue;

                    MapCoordsXY c = TransformToMapCoords({ vehicle->x, vehicle->y });

                    GfxFillRect(dpi, { { c.x, c.y }, { c.x, c.y } }, PALETTE_INDEX_171);
                }
            }
        }

        /**
         * The call to GfxFillRect was originally wrapped in Sub68DABD which made sure that arguments were ordered correctly,
         * but it doesn't look like it's ever necessary here so the call was removed.
         */
        void PaintHudRectangle(DrawPixelInfo& dpi)
        {
            WindowBase* mainWindow = WindowGetMain();
            if (mainWindow == nullptr)
                return;

            Viewport* mainViewport = mainWindow->viewport;
            if (mainViewport == nullptr)
                return;

            auto offset = MiniMapOffsets[GetCurrentRotation()];
            auto leftTop = ScreenCoordsXY{ (mainViewport->viewPos.x >> 5) + offset.x,
                                           (mainViewport->viewPos.y >> 4) + offset.y };
            auto rightBottom = ScreenCoordsXY{ ((mainViewport->viewPos.x + mainViewport->view_width) >> 5) + offset.x,
                                               ((mainViewport->viewPos.y + mainViewport->view_height) >> 4) + offset.y };
            auto rightTop = ScreenCoordsXY{ rightBottom.x, leftTop.y };
            auto leftBottom = ScreenCoordsXY{ leftTop.x, rightBottom.y };

            // top horizontal lines
            GfxFillRect(dpi, { leftTop, leftTop + ScreenCoordsXY{ 3, 0 } }, PALETTE_INDEX_56);
            GfxFillRect(dpi, { rightTop - ScreenCoordsXY{ 3, 0 }, rightTop }, PALETTE_INDEX_56);

            // left vertical lines
            GfxFillRect(dpi, { leftTop, leftTop + ScreenCoordsXY{ 0, 3 } }, PALETTE_INDEX_56);
            GfxFillRect(dpi, { leftBottom - ScreenCoordsXY{ 0, 3 }, leftBottom }, PALETTE_INDEX_56);

            // bottom horizontal lines
            GfxFillRect(dpi, { leftBottom, leftBottom + ScreenCoordsXY{ 3, 0 } }, PALETTE_INDEX_56);
            GfxFillRect(dpi, { rightBottom - ScreenCoordsXY{ 3, 0 }, rightBottom }, PALETTE_INDEX_56);

            // right vertical lines
            GfxFillRect(dpi, { rightTop, rightTop + ScreenCoordsXY{ 0, 3 } }, PALETTE_INDEX_56);
            GfxFillRect(dpi, { rightBottom - ScreenCoordsXY{ 0, 3 }, rightBottom }, PALETTE_INDEX_56);
        }

        void DrawTabImages(DrawPixelInfo& dpi)
        {
            // Guest tab image (animated)
            uint32_t guestTabImage = SPR_TAB_GUESTS_0;
            if (selected_tab == PAGE_PEEPS)
                guestTabImage += list_information_type / 4;

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

            // Ride/stall tab image (animated)
            uint32_t rideTabImage = SPR_TAB_RIDE_0;
            if (selected_tab == PAGE_RIDES)
                rideTabImage += list_information_type / 4;

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

        void ShowDefaultScenarioEditorButtons()
        {
            widgets[WIDX_BUILD_PARK_ENTRANCE].type = WindowWidgetType::FlatBtn;
            widgets[WIDX_PEOPLE_STARTING_POSITION].type = WindowWidgetType::FlatBtn;
            widgets[WIDX_MAP_SIZE_SPINNER_Y].type = WindowWidgetType::Spinner;
            widgets[WIDX_MAP_SIZE_SPINNER_Y_UP].type = WindowWidgetType::Button;
            widgets[WIDX_MAP_SIZE_SPINNER_Y_DOWN].type = WindowWidgetType::Button;
            widgets[WIDX_MAP_SIZE_LINK].type = WindowWidgetType::FlatBtn;
            widgets[WIDX_MAP_SIZE_SPINNER_X].type = WindowWidgetType::Spinner;
            widgets[WIDX_MAP_SIZE_SPINNER_X_UP].type = WindowWidgetType::Button;
            widgets[WIDX_MAP_SIZE_SPINNER_X_DOWN].type = WindowWidgetType::Button;

            // Only show this in the scenario editor, even when in sandbox mode.
            if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
                widgets[WIDX_MAP_GENERATOR].type = WindowWidgetType::Button;

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

        void InputLandSize()
        {
            Formatter ft;
            ft.Add<uint16_t>(kLandToolMinimumSize);
            ft.Add<uint16_t>(kLandToolMaximumSize);
            TextInputOpen(WIDX_LAND_TOOL, STR_SELECTION_SIZE, STR_ENTER_SELECTION_SIZE, ft, STR_NONE, STR_NONE, 3);
        }

        void InputMapSize(WidgetIndex callingWidget)
        {
            if (IsWidgetPressed(WIDX_MAP_SIZE_LINK))
                _resizeDirection = ResizeDirection::Both;
            else
                _resizeDirection = (callingWidget == WIDX_MAP_SIZE_SPINNER_Y) ? ResizeDirection::Y : ResizeDirection::X;

            Formatter ft;
            ft.Add<int16_t>(kMinimumMapSizePractical);
            ft.Add<int16_t>(kMaximumMapSizePractical);
            TextInputOpen(callingWidget, STR_MAP_SIZE_2, STR_ENTER_MAP_SIZE, ft, STR_NONE, STR_NONE, 4);
        }

        CoordsXY ScreenToMap(ScreenCoordsXY screenCoords)
        {
            screenCoords.x = ((screenCoords.x + 8) - kMaximumMapSizeTechnical) / 2;
            screenCoords.y = ((screenCoords.y + 8)) / 2;
            auto location = TileCoordsXY(screenCoords.y - screenCoords.x, screenCoords.x + screenCoords.y).ToCoordsXY();

            switch (GetCurrentRotation())
            {
                case 0:
                    return location;
                case 1:
                    return { MAXIMUM_MAP_SIZE_BIG - 1 - location.y, location.x };
                case 2:
                    return { MAXIMUM_MAP_SIZE_BIG - 1 - location.x, MAXIMUM_MAP_SIZE_BIG - 1 - location.y };
                case 3:
                    return { location.y, MAXIMUM_MAP_SIZE_BIG - 1 - location.x };
            }

            return { 0, 0 }; // unreachable
        }

        MapCoordsXY TransformToMapCoords(CoordsXY c)
        {
            int32_t x = c.x, y = c.y;

            switch (GetCurrentRotation())
            {
                case 3:
                    std::swap(x, y);
                    x = MAXIMUM_MAP_SIZE_BIG - 1 - x;
                    break;
                case 2:
                    x = MAXIMUM_MAP_SIZE_BIG - 1 - x;
                    y = MAXIMUM_MAP_SIZE_BIG - 1 - y;
                    break;
                case 1:
                    std::swap(x, y);
                    y = MAXIMUM_MAP_SIZE_BIG - 1 - y;
                    break;
                case 0:
                    break;
            }
            x /= 32;
            y /= 32;

            return { -x + y + kMaximumMapSizeTechnical - 8, x + y - 8 };
        }

        void ResizeMap()
        {
            widgets[WIDX_MAP].right = width - 4;

            if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode)
                widgets[WIDX_MAP].bottom = height - 1 - 72;
            else if (selected_tab == PAGE_RIDES)
                widgets[WIDX_MAP].bottom = height - 1 - (4 * kListRowHeight + 4);
            else
                widgets[WIDX_MAP].bottom = height - 1 - 14;
        }

        void CalculateTextLayout()
        {
            int32_t textOffset = 4 + kListRowHeight;
            _firstColumnWidth = 118;
            for (uint32_t i = 0; i < 4; i++)
            {
                const auto* labelStr = LanguageGetString(MapLabels[i]);
                _firstColumnWidth = std::max(textOffset + GfxGetStringWidth(labelStr, FontStyle::Medium), _firstColumnWidth);
            }

            textOffset += _firstColumnWidth + 4;
            min_width = WW;
            for (uint32_t i = 4; i < std::size(MapLabels); i++)
            {
                const auto* labelStr = LanguageGetString(MapLabels[i]);
                min_width = std::max(
                    static_cast<int16_t>(textOffset + GfxGetStringWidth(labelStr, FontStyle::Medium)), min_width);
            }
            width = std::max(min_width, width);
            _recalculateScrollbars = true;
        }
    };

    WindowBase* MapOpen()
    {
        try
        {
            WindowBase* w = WindowFocusOrCreate<MapWindow>(WindowClass::Map, 245, 259, WF_10);
            w->selected_tab = 0;
            w->list_information_type = 0;
            return w;
        }
        catch (const std::bad_alloc&)
        {
            return nullptr;
        }
    }

    void WindowMapReset()
    {
        WindowBase* w;

        // Check if window is even opened
        w = WindowBringToFrontByClass(WindowClass::Map);
        if (w == nullptr)
        {
            return;
        }

        auto* mapWindow = static_cast<MapWindow*>(w);
        mapWindow->ResetMap();
    }
} // namespace OpenRCT2::Ui::Windows