#include "querystring_gui.h"

#include "sortlist_type.h"

#include "stringfilter_type.h"

#include "string_func.h"

	typedef GUIList<StationClassID, StringFilter &> GUIStationClassList; ///< Type definition for the list to hold available station classes.

	static const uint EDITBOX_MAX_SIZE = 16; ///< The maximum number of characters for the filter edit box.

	static Listing   last_sorting;           ///< Default sorting of #GUIStationClassList.

	static Filtering last_filtering;         ///< Default filtering of #GUIStationClassList.

	static GUIStationClassList::SortFunction * const sorter_funcs[];   ///< Sort functions of the #GUIStationClassList.

	static GUIStationClassList::FilterFunction * const filter_funcs[]; ///< Filter functions of the #GUIStationClassList.

	GUIStationClassList station_classes;     ///< Available station classes.

	StringFilter string_filter;              ///< Filter for available station classes.

	QueryString filter_editbox;              ///< Filter editbox.

	/**

	 * Scrolls #WID_BRAS_NEWST_SCROLL so that the selected station class is visible.

	 *

	 * Note that this method should be called shortly after SelectClassAndStation() which will ensure

	 * an actual existing station class is selected, or the one at position 0 which will always be

	 * the default TTD rail station.

	 */

	void EnsureSelectedStationClassIsVisible()

	{

		uint pos = 0;

		for (auto station_class : this->station_classes) {

			if (station_class == _railstation.station_class) break;

			pos++;

		}

		this->vscroll->SetCount((int)this->station_classes.size());

		this->vscroll->ScrollTowards(pos);

	}

	BuildRailStationWindow(WindowDesc *desc, Window *parent, bool newstation) : PickerWindowBase(desc, parent), filter_editbox(EDITBOX_MAX_SIZE)

		/* Hide the station class filter if no stations other than the default one are available. */

		this->GetWidget<NWidgetStacked>(WID_BRAS_FILTER_CONTAINER)->SetDisplayedPlane(newstation ? 0 : SZSP_NONE);

			this->querystrings[WID_BRAS_FILTER_EDITBOX] = &this->filter_editbox;

			this->station_classes.SetListing(this->last_sorting);

			this->station_classes.SetFiltering(this->last_filtering);

			this->station_classes.SetSortFuncs(this->sorter_funcs);

			this->station_classes.SetFilterFuncs(this->filter_funcs);

		this->station_classes.ForceRebuild();

		BuildStationClassesAvailable();

		SelectClassAndStation();

		if (!newstation) {

			_railstation.station_class = StationClassID::STAT_CLASS_DFLT;

		} else {

			EnsureSelectedStationClassIsVisible();

			this->SetFocusedWidget(WID_BRAS_FILTER_EDITBOX);

		this->InvalidateData();

	/** Sort station classes by StationClassID. */

	static bool StationClassIDSorter(StationClassID const &a, StationClassID const &b)

	{

		return a < b;

	}

	/** Filter station classes by class name. */

	static bool CDECL TagNameFilter(StationClassID const * sc, StringFilter &filter)

	{

		char buffer[DRAW_STRING_BUFFER];

		GetString(buffer, StationClass::Get(*sc)->name, lastof(buffer));

		filter.ResetState();

		filter.AddLine(buffer);

		return filter.GetState();

	}

	/** Builds the filter list of available station classes. */

	void BuildStationClassesAvailable()

	{

		if (!this->station_classes.NeedRebuild()) return;

		this->station_classes.clear();

		for (uint i = 0; i < StationClass::GetClassCount(); i++) {

			StationClassID station_class_id = (StationClassID)i;

			if (station_class_id == StationClassID::STAT_CLASS_WAYP) {

				// Skip waypoints.

				continue;

			}

			StationClass *station_class = StationClass::Get(station_class_id);

			if (station_class->GetUISpecCount() == 0) continue;

			station_classes.push_back(station_class_id);

		}

		if (_railstation.newstations) {

			this->station_classes.Filter(this->string_filter);

			this->station_classes.shrink_to_fit();

			this->station_classes.RebuildDone();

			this->station_classes.Sort();

			this->vscroll->SetCount((uint)this->station_classes.size());

		}

	}

	/**

	 * Checks if the previously selected current station class and station

	 * can be shown as selected to the user when the dialog is opened.

	 */

	void SelectClassAndStation()

	{

		if (_railstation.station_class == StationClassID::STAT_CLASS_DFLT) {

			/* This happens during the first time the window is open during the game life cycle. */

			this->SelectOtherClass(StationClassID::STAT_CLASS_DFLT);

		} else {

			/* Check if the previously selected station class is not available anymore as a

			 * result of starting a new game without the corresponding NewGRF. */

			bool available = false;

			for (uint i = 0; i < StationClass::GetClassCount(); ++i) {

				if ((StationClassID)i == _railstation.station_class) {

					available = true;

					break;

				}

			}

			this->SelectOtherClass(available ? _railstation.station_class : StationClassID::STAT_CLASS_DFLT);

		}

	}

	/**

	 * Select the specified station class.

	 * @param station_class Station class select.

	 */

	void SelectOtherClass(StationClassID station_class)

	{

		_railstation.station_class = station_class;

	}

	void OnInvalidateData(int data = 0, bool gui_scope = true) override

	{

		if (!gui_scope) return;

		this->BuildStationClassesAvailable();

	}

	void OnEditboxChanged(int wid) override

	{

		string_filter.SetFilterTerm(this->filter_editbox.text.buf);

		this->station_classes.SetFilterState(!string_filter.IsEmpty());

		this->station_classes.ForceRebuild();

		this->InvalidateData();

	}

				for (auto station_class : this->station_classes) {

					d = maxdim(d, GetStringBoundingBox(StationClass::Get(station_class)->name));

				for (auto station_class : this->station_classes) {

					StationClass *stclass = StationClass::Get(station_class);

				for (auto station_class : this->station_classes) {

								StationClass::Get(station_class)->name,

								station_class == _railstation.station_class ? TC_WHITE : TC_BLACK);

				if (y >= (int)this->station_classes.size()) return;

				StationClassID station_class_id = this->station_classes[y];

				if (_railstation.station_class != station_class_id) {

					StationClass *station_class = StationClass::Get(station_class_id);

					_railstation.station_class = station_class_id;

					_railstation.station_count = station_class->GetSpecCount();

					_railstation.station_type  = 0;

					this->CheckSelectedSize(station_class->GetSpec(_railstation.station_type));

					NWidgetMatrix *matrix = this->GetWidget<NWidgetMatrix>(WID_BRAS_MATRIX);

					matrix->SetCount(_railstation.station_count);

					matrix->SetClicked(_railstation.station_type);

				if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);

				this->SetDirty();

				DeleteWindowById(WC_SELECT_STATION, 0);

Listing BuildRailStationWindow::last_sorting = { false, 0 };

Filtering BuildRailStationWindow::last_filtering = { false, 0 };

BuildRailStationWindow::GUIStationClassList::SortFunction * const BuildRailStationWindow::sorter_funcs[] = {

	&StationClassIDSorter,

};

BuildRailStationWindow::GUIStationClassList::FilterFunction * const BuildRailStationWindow::filter_funcs[] = {

	&TagNameFilter,

};

				NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BRAS_FILTER_CONTAINER),

					NWidget(NWID_HORIZONTAL), SetPadding(2, 2, 0, 5),

						NWidget(WWT_TEXT, COLOUR_DARK_GREEN), SetFill(0, 1), SetDataTip(STR_LIST_FILTER_TITLE, STR_NULL),

						NWidget(WWT_EDITBOX, COLOUR_GREY, WID_BRAS_FILTER_EDITBOX), SetFill(1, 0), SetResize(1, 0),

								SetDataTip(STR_LIST_FILTER_OSKTITLE, STR_LIST_FILTER_TOOLTIP),

					EndContainer(),

				EndContainer(),

	_railstation.station_class = StationClassID::STAT_CLASS_DFLT;

	WID_BRAS_FILTER_CONTAINER,     ///< Container for the filter text box for the station class list.

	WID_BRAS_FILTER_EDITBOX,       ///< Filter text box for the station class list.