#include "../stdafx.h"

#include "cm_station_gui.hpp"

#include "cm_hotkeys.hpp"

#include "../core/math_func.hpp"
#include "../command_type.h"
#include "../command_func.h"
#include "../company_func.h"
#include "../industry_map.h"
#include "../industry.h"
#include "../landscape.h"
#include "../newgrf_station.h"  // StationClassID
#include "../newgrf_house.h"  // GetHouseCallback
#include "../newgrf_cargo.h"  // GetCargoTranslation
#include "../object_type.h"
#include "../object_map.h"
#include "../station_base.h"
#include "../strings_func.h"  // GetString, SetDParam
#include "../tilehighlight_type.h"
#include "../town_map.h"
#include "../town.h"
#include "../viewport_func.h"
#include "../viewport_kdtree.h"
#include "../window_gui.h"
#include "../zoom_type.h"
#include "../zoom_func.h"

#include <sstream>


extern const Station *_viewport_highlight_station;
extern TileHighlightData _thd;
extern void MarkCatchmentTilesDirty();

extern DiagDirection _road_station_picker_orientation;
extern bool CheckDriveThroughRoadStopDirection(TileArea area, RoadBits r);
extern DiagDirection AutodetectRoadObjectDirection(TileIndex tile);
extern DiagDirection AutodetectDriveThroughRoadStopDirection(TileArea area);
extern bool CheckClickOnViewportSign(const Viewport *vp, int x, int y, const ViewportSign *sign);
extern Rect ExpandRectWithViewportSignMargins(Rect r, ZoomLevel zoom);
extern ViewportSignKdtree _viewport_sign_kdtree;
extern AirportClassID _selected_airport_class;
extern int _selected_airport_index;
extern byte _selected_airport_layout;

extern RailType _cur_railtype;  // rail_gui.cpp

struct RailStationGUISettings {
    Axis orientation;                 ///< Currently selected rail station orientation

    bool newstations;                 ///< Are custom station definitions available?
    StationClassID station_class;     ///< Currently selected custom station class (if newstations is \c true )
    byte station_type;                ///< %Station type within the currently selected custom station class (if newstations is \c true )
    byte station_count;               ///< Number of custom stations (if newstations is \c true )
};
extern RailStationGUISettings _railstation; //rail_gui.cpp

namespace citymania {

StationBuildingStatus _station_building_status = StationBuildingStatus::NEW;
const Station *_station_to_join = nullptr;
const Station *_highlight_station_to_join = nullptr;
TileArea _highlight_join_area;

// void SetStationTileSelectSize(int w, int h, int catchment) {
//     _station_select.w = w;
//     _station_select.h = h;
//     _station_select.catchment = catchment;
// }

void SetStationBiildingStatus(StationBuildingStatus status) {
    _station_building_status = status;
};

static const int MAX_TILE_EXTENT_LEFT   = ZOOM_LVL_BASE * TILE_PIXELS;                     ///< Maximum left   extent of tile relative to north corner.
static const int MAX_TILE_EXTENT_RIGHT  = ZOOM_LVL_BASE * TILE_PIXELS;                     ///< Maximum right  extent of tile relative to north corner.
static const int MAX_TILE_EXTENT_TOP    = ZOOM_LVL_BASE * MAX_BUILDING_PIXELS;             ///< Maximum top    extent of tile relative to north corner (not considering bridges).
static const int MAX_TILE_EXTENT_BOTTOM = ZOOM_LVL_BASE * (TILE_PIXELS + 2 * TILE_HEIGHT); ///< Maximum bottom extent of tile relative to north corner (worst case: #SLOPE_STEEP_N).

void MarkTileAreaDirty(const TileArea &ta) {
    if (ta.tile == INVALID_TILE) return;
    auto x = TileX(ta.tile);
    auto y = TileY(ta.tile);
    Point p1 = RemapCoords(x * TILE_SIZE, y * TILE_SIZE, TileHeight(ta.tile) * TILE_HEIGHT);
    Point p2 = RemapCoords((x + ta.w)  * TILE_SIZE, (y + ta.h) * TILE_SIZE, TileHeight(TileXY(x + ta.w - 1, y + ta.h - 1)) * TILE_HEIGHT);
    Point p3 = RemapCoords((x + ta.w)  * TILE_SIZE, y * TILE_SIZE, TileHeight(TileXY(x + ta.w - 1, y)) * TILE_HEIGHT);
    Point p4 = RemapCoords(x * TILE_SIZE, (y + ta.h) * TILE_SIZE, TileHeight(TileXY(x, y + ta.h - 1)) * TILE_HEIGHT);
    MarkAllViewportsDirty(
            p3.x - MAX_TILE_EXTENT_LEFT,
            p4.x - MAX_TILE_EXTENT_TOP,
            p1.y + MAX_TILE_EXTENT_RIGHT,
            p2.y + MAX_TILE_EXTENT_BOTTOM);
}

static void UpdateHiglightJoinArea(const Station *station) {
    if (!station) {
        MarkTileAreaDirty(_highlight_join_area);
        _highlight_join_area.tile = INVALID_TILE;
        return;
    }
    auto &r = _station_to_join->rect;
    auto d = (int)_settings_game.station.station_spread - 1;
    TileArea ta(
        TileXY(std::max<int>(r.right - d, 0),
               std::max<int>(r.bottom - d, 0)),
        TileXY(std::min<int>(r.left + d, MapSizeX() - 1),
               std::min<int>(r.top + d, MapSizeY() - 1))
    );
    if (_highlight_join_area.tile == ta.tile &&
        _highlight_join_area.w == ta.w &&
        _highlight_join_area.h == ta.h) return;
    MarkTileAreaDirty(_highlight_join_area);
    _highlight_join_area = ta;
    MarkTileAreaDirty(_highlight_join_area);
}

static void MarkCoverageAreaDirty(const Station *station) {
    MarkTileAreaDirty(station->catchment_tiles);
}

void MarkCoverageHighlightDirty() {
    MarkCatchmentTilesDirty();
}

void SetHighlightStationToJoin(const Station *station, bool with_area) {
    UpdateHiglightJoinArea(with_area ? station : nullptr);

    if (_highlight_station_to_join == station) return;

    if (_highlight_station_to_join && _settings_client.gui.station_show_coverage)
        MarkCoverageAreaDirty(_highlight_station_to_join);
    _highlight_station_to_join = station;
    if (_highlight_station_to_join && _settings_client.gui.station_show_coverage)
        MarkCoverageAreaDirty(_highlight_station_to_join);
}

void OnStationTileSetChange(const Station *station, bool adding, StationType type) {
    if (station == _highlight_station_to_join) {
        if (_highlight_join_area.tile != INVALID_TILE)
            UpdateHiglightJoinArea(_station_to_join);
        if (_settings_client.gui.station_show_coverage)
            MarkCoverageAreaDirty(_highlight_station_to_join);
    }
    if (station == _viewport_highlight_station) MarkCoverageAreaDirty(_viewport_highlight_station);
}

CommandContainer _last_station_bulid_cmd;

void OnStationPartBuilt(const Station *station, TileIndex tile, uint32 p1, uint32 p2) {
    if (_current_company != _local_company) return;
    if (tile != _last_station_bulid_cmd.tile ||
        p1 != _last_station_bulid_cmd.p1 ||
        p2 != _last_station_bulid_cmd.p2) return;
    _station_to_join = station;
    CheckRedrawStationCoverage();
}

const Station *CheckClickOnDeadStationSign() {
    int x = _cursor.pos.x;
    int y = _cursor.pos.y;
    Window *w = FindWindowFromPt(x, y);
    if (w == nullptr) return nullptr;
    Viewport *vp = IsPtInWindowViewport(w, x, y);

    if (!HasBit(_display_opt, DO_SHOW_STATION_NAMES) && !IsInvisibilitySet(TO_SIGNS))
        return nullptr;

    x = ScaleByZoom(x - vp->left, vp->zoom) + vp->virtual_left;
    y = ScaleByZoom(y - vp->top, vp->zoom) + vp->virtual_top;

    Rect search_rect{ x - 1, y - 1, x + 1, y + 1 };
    search_rect = ExpandRectWithViewportSignMargins(search_rect, vp->zoom);

    const Station *last_st = nullptr;
    _viewport_sign_kdtree.FindContained(search_rect.left, search_rect.top, search_rect.right, search_rect.bottom, [&](const ViewportSignKdtreeItem & item) {
        if (item.type != ViewportSignKdtreeItem::VKI_STATION) return;
        auto st = Station::Get(item.id.station);
        if (st->IsInUse()) return;
        if (_local_company != st->owner) return;
        if (CheckClickOnViewportSign(vp, x, y, &st->sign)) last_st = st;
    });
    return last_st;
}

bool CheckStationJoin(TileIndex start_tile, TileIndex end_tile) {
    // if (_ctrl_pressed && start_tile == end_tile) {
    if (citymania::_fn_mod) {
        if (IsTileType (start_tile, MP_STATION)) {
            citymania::SelectStationToJoin(Station::GetByTile(start_tile));
            return true;
        }
        auto st = CheckClickOnDeadStationSign();
        if (st) {
            citymania::SelectStationToJoin(st);
            return true;
        }
    }
    return false;
}

void JoinAndBuild(CommandContainer cmdcont) {
    auto join_to = _highlight_station_to_join;
    uint32 adj_bit = ((citymania::_fn_mod || join_to) ? 1 : 0);
    auto cmd = (cmdcont.cmd & CMD_ID_MASK);
    if (cmd == CMD_BUILD_RAIL_STATION) {
        SB(cmdcont.p1, 24, 1, adj_bit);
    } else if (cmd == CMD_BUILD_ROAD_STOP) {
        SB(cmdcont.p2, 2, 1, adj_bit);
    } else if (cmd == CMD_BUILD_DOCK) {
        SB(cmdcont.p1, 0, 1, adj_bit);
    } else if (cmd == CMD_BUILD_AIRPORT) {
        SB(cmdcont.p2, 0, 1, adj_bit);
    }
    if (citymania::_fn_mod) SB(cmdcont.p2, 16, 16, NEW_STATION);
    else if (join_to) SB(cmdcont.p2, 16, 16, join_to->index);
    else SB(cmdcont.p2, 16, 16, INVALID_STATION);

    _last_station_bulid_cmd = cmdcont;
    DoCommandP(&cmdcont);
}

void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, uint32 p2, uint32 cmd) {
    uint8 ddir = _road_station_picker_orientation;
    SB(p2, 16, 16, INVALID_STATION); // no station to join
    TileArea ta(start_tile, end_tile);

    if (CheckStationJoin(start_tile, end_tile)) return;

    if (ddir >= DIAGDIR_END) {
        if (ddir < DIAGDIR_END + 2) {
            SetBit(p2, 1); // It's a drive-through stop.
            ddir -= DIAGDIR_END; // Adjust picker result to actual direction.
            // When placed on road autorotate anyway
            if (ddir == DIAGDIR_SE) {
                if (!CheckDriveThroughRoadStopDirection(ta, ROAD_Y))
                    ddir = DIAGDIR_NE;
            } else {
                if (!CheckDriveThroughRoadStopDirection(ta, ROAD_X))
                    ddir = DIAGDIR_SE;
            }
        }
        else if (ddir == DIAGDIR_END + 2) {
            ddir = AutodetectRoadObjectDirection(start_tile);
        }
        else if (ddir == DIAGDIR_END + 3) {
            SetBit(p2, 1); // It's a drive-through stop.
            ddir = AutodetectDriveThroughRoadStopDirection(ta);
        }
    }
    p2 |= ddir << 3; // Set the DiagDirecion into p2 bits 3 and 4.

    CommandContainer cmdcont = { ta.tile, (uint32)(ta.w | ta.h << 8), p2, cmd, CcRoadStop, "" };
    JoinAndBuild(cmdcont);
}

void HandleStationPlacement(TileIndex start, TileIndex end)
{
    if (CheckStationJoin(start, end)) return;

    TileArea ta(start, end);
    uint numtracks = ta.w;
    uint platlength = ta.h;

    if (_railstation.orientation == AXIS_X) Swap(numtracks, platlength);

    uint32 p1 = _cur_railtype | _railstation.orientation << 6 | numtracks << 8 | platlength << 16 | (citymania::_fn_mod ? 1 << 24 : 0);
    uint32 p2 = _railstation.station_class | _railstation.station_type << 8 | INVALID_STATION << 16;

    CommandContainer cmdcont = { ta.tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" };
    JoinAndBuild(cmdcont);
}

void PlaceRail_Station(TileIndex tile) {
    if (CheckStationJoin(tile, tile)) return;

    uint32 p1 = _cur_railtype | _railstation.orientation << 6 | _settings_client.gui.station_numtracks << 8 | _settings_client.gui.station_platlength << 16 | (citymania::_fn_mod ? 1 << 24 : 0);
    uint32 p2 = _railstation.station_class | _railstation.station_type << 8 | INVALID_STATION << 16;

    int w = _settings_client.gui.station_numtracks;
    int h = _settings_client.gui.station_platlength;
    if (!_railstation.orientation) Swap(w, h);

    CommandContainer cmdcont = { tile, p1, p2, CMD_BUILD_RAIL_STATION | CMD_MSG(STR_ERROR_CAN_T_BUILD_RAILROAD_STATION), CcStation, "" };
    JoinAndBuild(cmdcont);
}

void PlaceDock(TileIndex tile) {
    if (CheckStationJoin(tile, tile)) return;

    uint32 p2 = (uint32)INVALID_STATION << 16; // no station to join

    /* tile is always the land tile, so need to evaluate _thd.pos */
    CommandContainer cmdcont = { tile, citymania::_fn_mod, p2, CMD_BUILD_DOCK | CMD_MSG(STR_ERROR_CAN_T_BUILD_DOCK_HERE), CcBuildDocks, "" };

    /* Determine the watery part of the dock. */
    // DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
    // TileIndex tile_to = (dir != INVALID_DIAGDIR ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile);

    JoinAndBuild(cmdcont);
}

void PlaceAirport(TileIndex tile) {
    if (CheckStationJoin(tile, tile)) return;

    if (_selected_airport_index == -1) return;

    uint32 p2 = (citymania::_fn_mod ? 1 : 0);
    SB(p2, 16, 16, INVALID_STATION); // no station to join

    uint32 p1 = AirportClass::Get(_selected_airport_class)->GetSpec(_selected_airport_index)->GetIndex();
    p1 |= _selected_airport_layout << 8;
    CommandContainer cmdcont = { tile, p1, p2, CMD_BUILD_AIRPORT | CMD_MSG(STR_ERROR_CAN_T_BUILD_AIRPORT_HERE), CcBuildAirport, "" };
    JoinAndBuild(cmdcont);
}

static void FindStationsAroundSelection(const TileArea &location)
{
    /* Extended area by one tile */
    int x = TileX(location.tile);
    int y = TileY(location.tile);

    TileArea ta(TileXY(std::max<int>(0, x - 1), std::max<int>(0, y - 1)), TileXY(std::min<int>(MapMaxX() - 1, x + location.w + 1), std::min<int>(MapMaxY() - 1, y + location.h + 1)));

    Station *adjacent = nullptr;

    /* Direct loop instead of FindStationsAroundTiles as we are not interested in catchment area */
    TILE_AREA_LOOP(tile, ta) {
        if (IsTileType(tile, MP_STATION) && GetTileOwner(tile) == _local_company) {
            Station *st = Station::GetByTile(tile);
            if (st == nullptr) continue;

            int tx = TileX(tile);
            int ty = TileY(tile);
            bool is_corner = ((tx == x - 1 || tx == x + location.w + 1) && (ty == y - 1 || ty == y + location.h + 1));

            if (adjacent && is_corner) continue;
            adjacent = st;
            if (!is_corner) break;
        }
    }
    SetHighlightStationToJoin(adjacent, false);
    _station_building_status = (adjacent == nullptr ? StationBuildingStatus::NEW : StationBuildingStatus::JOIN);
}

bool CheckRedrawStationCoverage() {
    // static bool last_ctrl_pressed = false;
    static TileArea last_location;
    static bool last_station_mode = false;
    static bool last_fn_mod = false;
    TileArea location(TileVirtXY(_thd.pos.x, _thd.pos.y), _thd.size.x / TILE_SIZE - 1, _thd.size.y / TILE_SIZE - 1);
    bool station_mode = ((_thd.drawstyle & HT_DRAG_MASK) == HT_RECT && _thd.outersize.x > 0);
    bool location_changed = (location.tile != last_location.tile ||  location.w != last_location.w || location.h != last_location.h);
    bool mode_changed = (last_station_mode != station_mode);
    if (!location_changed && citymania::_fn_mod == last_fn_mod && !mode_changed)
        return false;

    last_fn_mod = citymania::_fn_mod;
    last_location = location;
    last_station_mode = station_mode;

    if (citymania::_fn_mod) {
        Station *st = nullptr;
        if (IsTileType(location.tile, MP_STATION) && GetTileOwner(location.tile) == _local_company)
            st = Station::GetByTile(location.tile);

        SetHighlightStationToJoin(st, _station_to_join && st == _station_to_join);
        _station_building_status = (st == nullptr ? StationBuildingStatus::NEW : StationBuildingStatus::JOIN);
    } else {
        if (_station_to_join) {
            SetHighlightStationToJoin(_station_to_join, true);
            _station_building_status = StationBuildingStatus::JOIN;
        } else {
            FindStationsAroundSelection(location);
        }
    }
    return true;
}


void SelectStationToJoin(const Station *station) {
    if (_station_to_join == station)
        _station_to_join = nullptr;
    else
        _station_to_join = station;
    CheckRedrawStationCoverage();
}

void AbortStationPlacement() {
    _station_to_join = nullptr;
    SetHighlightStationToJoin(nullptr, false);
}


uint GetMonthlyFrom256Tick(uint amount) {
    return ((amount * DAY_TICKS * 30) >> 8);
}

uint GetAverageHouseProduction(byte amount) {
    static const uint AVG[2][256] = {
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 22, 24, 27, 30, 33, 36, 39, 42, 45, 48, 52, 56, 60, 64, 68, 72, 76, 80, 85, 90, 95, 100, 105, 110, 115, 120, 126, 132, 138, 144, 150, 156, 162, 168, 175, 182, 189, 196, 203, 210, 217, 224, 232, 240, 248, 256, 264, 272, 280, 288, 297, 306, 315, 324, 333, 342, 351, 360, 370, 380, 390, 400, 410, 420, 430, 440, 451, 462, 473, 484, 495, 506, 517, 528, 540, 552, 564, 576, 588, 600, 612, 624, 637, 650, 663, 676, 689, 702, 715, 728, 742, 756, 770, 784, 798, 812, 826, 840, 855, 870, 885, 900, 915, 930, 945, 960, 976, 992, 1008, 1024, 1040, 1056, 1072, 1088, 1105, 1122, 1139, 1156, 1173, 1190, 1207, 1224, 1242, 1260, 1278, 1296, 1314, 1332, 1350, 1368, 1387, 1406, 1425, 1444, 1463, 1482, 1501, 1520, 1540, 1560, 1580, 1600, 1620, 1640, 1660, 1680, 1701, 1722, 1743, 1764, 1785, 1806, 1827, 1848, 1870, 1892, 1914, 1936, 1958, 1980, 2002, 2024, 2047, 2070, 2093, 2116, 2139, 2162, 2185, 2208, 2232, 2256, 2280, 2304, 2328, 2352, 2376, 2400, 2425, 2450, 2475, 2500, 2525, 2550, 2575, 2600, 2626, 2652, 2678, 2704, 2730, 2756, 2782, 2808, 2835, 2862, 2889, 2916, 2943, 2970, 2997, 3024, 3052, 3080, 3108, 3136, 3164, 3192, 3220, 3248, 3277, 3306, 3335, 3364, 3393, 3422, 3451, 3480, 3510, 3540, 3570, 3600, 3630, 3660, 3690, 3720, 3751, 3782, 3813, 3844, 3875, 3906, 3937, 3968, 4000, 4032, 4064, 4096, 4128, 4160, 4192},
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230, 235, 240, 246, 252, 258, 264, 270, 276, 282, 288, 294, 300, 306, 312, 318, 324, 330, 336, 343, 350, 357, 364, 371, 378, 385, 392, 399, 406, 413, 420, 427, 434, 441, 448, 456, 464, 472, 480, 488, 496, 504, 512, 520, 528, 536, 544, 552, 560, 568, 576, 585, 594, 603, 612, 621, 630, 639, 648, 657, 666, 675, 684, 693, 702, 711, 720, 730, 740, 750, 760, 770, 780, 790, 800, 810, 820, 830, 840, 850, 860, 870, 880, 891, 902, 913, 924, 935, 946, 957, 968, 979, 990, 1001, 1012, 1023, 1034, 1045, 1056, 1068, 1080, 1092, 1104, 1116, 1128, 1140, 1152, 1164, 1176, 1188, 1200, 1212, 1224, 1236, 1248, 1261, 1274, 1287, 1300, 1313, 1326, 1339, 1352, 1365, 1378, 1391, 1404, 1417, 1430, 1443, 1456, 1470, 1484, 1498, 1512, 1526, 1540, 1554, 1568, 1582, 1596, 1610, 1624, 1638, 1652, 1666, 1680, 1695, 1710, 1725, 1740, 1755, 1770, 1785, 1800, 1815, 1830, 1845, 1860, 1875, 1890, 1905, 1920, 1936, 1952, 1968, 1984, 2000, 2016, 2032, 2048, 2064, 2080, 2096, 2112, 2128, 2144, 2160}
    };
    if (amount == 0) return 0;
    switch (_settings_game.economy.town_cargogen_mode) {
        case TCGM_ORIGINAL:
            return GetMonthlyFrom256Tick(AVG[EconomyIsInRecession() ? 1 : 0][amount]);
        case TCGM_BITCOUNT: {
            uint amt = (amount + 7) / 8;
            if (EconomyIsInRecession()) amt += 2;
            else amt *= 2;
            return GetMonthlyFrom256Tick(amt * 16);
        }
        default:
            NOT_REACHED();
    }
    return 0;
}

static void AddProducedCargo_Town(TileIndex tile, CargoArray &produced)
{
    if (!IsHouseCompleted(tile)) return;

    HouseID house_id = GetHouseType(tile);
    const HouseSpec *hs = HouseSpec::Get(house_id);
    Town *t = Town::GetByTile(tile);

    if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
        for (uint i = 0; i < 256; i++) {
            uint16 callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, 0, house_id, t, tile);

            if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;

            CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grf_prop.grffile);

            if (cargo == CT_INVALID) continue;
            produced[cargo] += GetMonthlyFrom256Tick((uint)GB(callback, 0, 8)) ;
        }
    } else {
        produced[CT_PASSENGERS] += GetAverageHouseProduction(hs->population);
        produced[CT_MAIL] += GetAverageHouseProduction(hs->mail_generation);
    }
}

// Similar to ::GetProductionAroundTiles but counts production total
CargoArray GetProductionAroundTiles(TileIndex tile, int w, int h, int rad)
{
    static const uint HQ_AVG_POP[2][5] = {
        {48, 64, 84, 128, 384},
        {48, 64, 84, 128, 256},
    };
    static const uint HQ_AVG_MAIL[2][5] = {
        {36, 48, 64, 96, 264},
        {36, 48, 64, 96, 196}
    };

    CargoArray produced;
    std::set<IndustryID> industries;
    TileArea ta = TileArea(tile, w, h).Expand(rad);

    /* Loop over all tiles to get the produced cargo of
     * everything except industries */
    TILE_AREA_LOOP(tile, ta) {
        switch (GetTileType(tile)) {
            case MP_INDUSTRY:
                industries.insert(GetIndustryIndex(tile));
                break;
            case MP_HOUSE:
                AddProducedCargo_Town(tile, produced);
                break;
            case MP_OBJECT:
                if (IsObjectType(tile, OBJECT_HQ)) {
                    produced[CT_PASSENGERS] += GetMonthlyFrom256Tick(HQ_AVG_POP[EconomyIsInRecession() ? 1 : 0][GetAnimationFrame(tile)]);
                    produced[CT_MAIL] += GetMonthlyFrom256Tick(HQ_AVG_MAIL[EconomyIsInRecession() ? 1 : 0][GetAnimationFrame(tile)]);
                }
            default: break;
        }
    }

    /* Loop over the seen industries. They produce cargo for
     * anything that is within 'rad' of any one of their tiles.
     */
    for (IndustryID industry : industries) {
        const Industry *i = Industry::Get(industry);
        /* Skip industry with neutral station */
        if (i->neutral_station != nullptr && !_settings_game.station.serve_neutral_industries) continue;

        for (uint j = 0; j < lengthof(i->produced_cargo); j++) {
            CargoID cargo = i->produced_cargo[j];
            if (cargo != CT_INVALID) produced[cargo] += ((uint)i->last_month_production[j]) << 8;
        }
    }

    return produced;
}

std::string GetStationCoverageProductionText(TileIndex tile, int w, int h, int rad, StationCoverageType sct) {
    auto production = GetProductionAroundTiles(tile, w, h, rad);

    std::ostringstream s;
    char buffer[DRAW_STRING_BUFFER];
    GetString(buffer, STR_CM_STATION_BUILD_SUPPLIES, lastof(buffer));
    s << buffer;
    bool first = true;
    for (CargoID i = 0; i < NUM_CARGO; i++) {
        switch (sct) {
            case SCT_PASSENGERS_ONLY: if (!IsCargoInClass(i, CC_PASSENGERS)) continue; break;
            case SCT_NON_PASSENGERS_ONLY: if (IsCargoInClass(i, CC_PASSENGERS)) continue; break;
            case SCT_ALL: break;
            default: NOT_REACHED();
        }
        if (production[i] == 0) continue;
        if (!first) s << ", ";
        first = false;
        SetDParam(0, i);
        SetDParam(1, production[i] >> 8);
        // GetString(buffer, STR_CM_STATION_BUILD_SUPPLIES_CARGO, lastof(buffer));
        GetString(buffer, STR_JUST_CARGO, lastof(buffer));
        s << buffer;
    }
    return s.str();
}

} // namespace citymania