buypeeb-cs/MainWindow.cs

/*
buypeeb - a program to track yahoo jp auctions of peebus.
Copyright (C) 2021 lynnesbian

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Text.Unicode;
using System.Threading;
using System.Threading.Tasks;
using CsvHelper;
using Gtk;
using Timeout = GLib.Timeout;

// ReSharper disable UnusedParameter.Local

namespace Buypeeb {
	[SuppressMessage("ReSharper", "UnusedMember.Local")]
	internal class MainWindow : Window {

		private static readonly SemaphoreSlim TaskLimit = new(6);
		private readonly Builder builder;
		private readonly Label endingLabel;
		private readonly Dictionary<string, CheckButton> filterChecks = new();
		private readonly HttpClient httpClient;

		private readonly ListStore items;
		private readonly TreeView itemTreeView;
		private readonly JsonSerializerOptions jsonOptions;
		private readonly string location;
		private readonly SearchEntry searchEntry;

		// TODO: whenever we get something from the builder, cache it for later
		// that way we don't need to constantly do "builder.GetObject"s

		private readonly Box selectionViewBox;
		private readonly Queue<string> updateQueue = new();
		private bool queueActive;
		private Settings settings;

		public MainWindow() : this(new Builder("main.glade")) {
		}

		private MainWindow(Builder builder) : base(builder.GetObject("wndMain").Handle) {
			jsonOptions = new JsonSerializerOptions {
				// enable full unicode support to ensure that japanese characters are saved properly
				Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
			};

			if (Environment.OSVersion.Platform ==
			    PlatformID.Win32NT) // C:\Users\Beebus\AppData\Roaming\Lynnear Software\buypeeb
			{
				location = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
					"Lynnear Software", "buypeeb");
			} else // ~/.config/Lynnear Software/buypeeb
			{
				location = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".config",
					"Lynnear Software", "buypeeb");
			}

			// initialise http client
			httpClient = new HttpClient();

			var userdata = System.IO.Path.Combine(location, "userdata.json");
			if (File.Exists(userdata)) {
				try {
					var j = File.ReadAllText(userdata);
					settings = JsonSerializer.Deserialize<Settings>(j);
				} catch {
					// ???
					Console.WriteLine("oops");
					Application.Quit();
				}
			} else {
				settings = new Settings();
			}

			SaveSettings();
			Title = "Buypeeb";

			// build main window UI
			this.builder = builder;
			builder.Autoconnect(this);

			// hide the (currently non-functional) help button
			((ToolButton) builder.GetObject("HelpButton")).Visible = false;

			var menuButtonFilter = (MenuButton) builder.GetObject("MenuButtonFilter");
			var menuButtonSort = (MenuButton) builder.GetObject("MenuButtonSort");
			menuButtonFilter.Child = (Image) builder.GetObject("ImageFilter");
			menuButtonSort.Child = (Image) builder.GetObject("ImageSort");

			selectionViewBox = (Box) builder.GetObject("SelectionViewBox");
			endingLabel = (Label) builder.GetObject("LabelSelectedEnding");
			searchEntry = (SearchEntry) builder.GetObject("FilterSearchEntry");

			// construct the list of filters, and ensure they're all disabled
			foreach (var name in new List<string> {
				"Favourites", "NonFavourites", "Active", "Ended", "EndingToday", "EndingAfterToday", "WithWinPrice",
				"WithNoWinPrice",
			}) {
				filterChecks.Add(name, (CheckButton) builder.GetObject($"CheckButtonFilter{name}"));
				filterChecks[name].Active = false;
			}

			// bind treeview columns to watchlist instead of needing to manually sync its liststore
			itemTreeView = (TreeView) builder.GetObject("TreeViewItems");
			items = new ListStore(typeof(YahooAuctionsItem));
			var filteredItems = new TreeModelFilter(items, null) {VisibleFunc = ItemFilter};

			itemTreeView.Model = filteredItems;
			// functions for rendering text to the associated columns
			TreeCellDataFunc[] funcs = {
				RenderColumnFavourite,
				RenderColumnName,
				RenderColumnPriceYen,
				RenderColumnPriceAUD,
				RenderColumnEnding,
			};

			for (var i = 0; i < itemTreeView.Columns.Length; i++) {
				var c = itemTreeView.Columns[i];
				c.SetCellDataFunc(c.Cells[0], funcs[i]);
			}

			RenderList();
			UpdateItems();
			Timeout.Add(1000, UpdateSelectionEndTime);
			Timeout.Add(10000, AutoUpdateItems);

			DeleteEvent += WindowShutdown;
		}

		private IEnumerable<YahooAuctionsItem> filterQuery =>
			// father forgive me for i have lynned
			from item in settings.watchlist.Values.ToList()
			where (item.favourite != filterChecks["Favourites"].Active ||
			       item.favourite == filterChecks["NonFavourites"].Active) &&
			      (item.Available != filterChecks["Active"].Active ||
			       item.Available == filterChecks["Ended"].Active) &&
			      (item.endingToday != filterChecks["EndingToday"].Active ||
			       item.endingToday == filterChecks["EndingAfterToday"].Active) &&
			      (item.hasWinPrice != filterChecks["WithWinPrice"].Active ||
			       item.hasWinPrice == filterChecks["WithNoWinPrice"].Active) &&
			      (string.IsNullOrWhiteSpace(searchEntry.Text) ||
			       item.name.ToLower().Contains(searchEntry.Text.ToLower()) ||
			       item.originalName.ToLower().Contains(searchEntry.Text.ToLower()))
			select item;

		private IEnumerable<YahooAuctionsItem> outdatedItemQuery =>
			// only returns items that meet all of the following:
			// - marked as "ready", as in, they aren't in the process of updating
			// - not updated since the interval
			// - hasn't already ended
			from item in settings.watchlist.Values.ToList()
			where item.Ready && settings.ItemNotUpdatedSinceInterval(item) && item.endDate.CompareTo(DateTime.UtcNow) > 0
			select item;

		private YahooAuctionsItem selectedItem {
			get {
				if (itemTreeView.Selection.CountSelectedRows() == 0) // avoids incurring the wrath of Gtk-CRITICAL **
				{
					return null;
				}

				itemTreeView.Selection.GetSelected(out var iter);
				return (YahooAuctionsItem) itemTreeView.Model.GetValue(iter, 0);
			}
		}

		private void WindowShutdown(object sender, DeleteEventArgs args) {
			SaveSettings();
			Application.Quit();
		}

		// general behaviour

		/// <summary>
		///   gets the path and iter for a given item id.
		/// </summary>
		/// <param name="id">the item id to find in the treeview</param>
		/// <returns>a tuple of (TreePath, TreeIter)</returns>
		private (TreePath path, TreeIter iter) GetRow(string id) {
			// TODO: surely there's a better way to do this
			itemTreeView.Model.GetIterFirst(out var iter);
			var m = (TreeModelFilter) itemTreeView.Model;

			for (var i = 0; i < itemTreeView.Model.IterNChildren(); i++) {
				var x = (YahooAuctionsItem) itemTreeView.Model.GetValue(iter, 0);
				if (x.id == id) {
					return (m.ConvertPathToChildPath(m.GetPath(iter)), m.ConvertIterToChildIter(iter));
				}

				itemTreeView.Model.IterNext(ref iter);
			}

			Console.WriteLine($"Couldn't find {id}!");
			return (null, iter);
		}

		/// <summary>
		///   saves the settings to userdata.json.
		/// </summary>
		private void SaveSettings() {
			var j = JsonSerializer.Serialize(settings, jsonOptions);
			var p = System.IO.Path.Combine(location, "userdata.json");
			Console.WriteLine(j);
			if (!Directory.Exists(location)) {
				Directory.CreateDirectory(location);
			}

			using var fs = File.CreateText(p);
			fs.Write(j);
		}

		/// <summary>
		///   updates the item with the given id. this method blocks and is intended to be run from a task.
		/// </summary>
		/// <param name="id">the id of the item to update</param>
		private async void UpdateThread(string id) {
			var item = settings.watchlist[id];
			// Console.WriteLine($"Updating {id}...");
			// set item.ready to false to show that it's still being updated
			// this changes a few behaviours, such as displaying the price as "..." instead of whatever is currently stored
			item.Ready = false;

			Application.Invoke(delegate {
				// TODO: find a way to not have to do this. i think we need to avoid actually modifying the items outside of the
				// main thread :/
				var (path, iter) = GetRow(id);
				if (path != null) {
					items.EmitRowChanged(path, iter);
				}
			});

			try {
				item.Update(await httpClient.GetStringAsync(item.url));
			} catch (HttpRequestException e) {
				if (e.StatusCode == HttpStatusCode.NotFound) {
					item.AuctionEnded();
				} else {
					Console.WriteLine($"Failed to update item ${id}! Status code ${e.StatusCode}: ${e.Message}");
				}
			}

			Application.Invoke(delegate {
				var (path, iter) = GetRow(id);
				if (path != null) {
					items.EmitRowChanged(path, iter);
				}

				if (item == selectedItem) {
					// if the user has this item selected and it just became ready, enable the selection box and redraw the info
					selectionViewBox.Sensitive = true;
					UpdateSelectionView();
				}
			});

			item.Ready = true;
			// Console.WriteLine($"{id} updated.");
		}

		/// <summary>
		///   processes the update queue. this is a blocking function.
		/// </summary>
		private void ProcessUpdateQueue() {
			queueActive = true;
			while (queueActive) {
				UpdateItem(updateQueue.Dequeue());
				queueActive = updateQueue.TryPeek(out _);
			}
		}

		/// <summary>
		///   updates an item with the given id with a new task.
		/// </summary>
		/// <param name="id">the id of the task to update</param>
		/// <param name="renderListWhenDone">whether or not to call this.RenderList() after updating the item</param>
		private void UpdateItem(string id, bool renderListWhenDone = false) {
			if (settings.watchlist[id].updatedRecently) {
				return;
			}

			// don't start a new task if there are more than `tasklimit` tasks currently running
			// this makes sure we don't make 1000 simultaneous requests to yahoo auctions if there are 1000 items on the
			// watchlist
			TaskLimit.Wait();
			Task.Factory.StartNew(() => { UpdateThread(id); }).ContinueWith(task => {
				TaskLimit.Release();
				if (renderListWhenDone) {
					Application.Invoke(delegate { RenderList(); });
				}
			});
		}

		/// <summary>
		///   add every item in the watchlist to the update queue. if the update queue is already being processed
		///   (this.queueActive), this will do nothing.
		/// </summary>
		private void UpdateItems() {
			if (queueActive) {
				return;
			}

			selectionViewBox.Sensitive = false;
			foreach (var item in settings.watchlist) {
				if (!updateQueue.Contains(item.Key)) {
					// set everything to not ready first
					// ensures other actions don't attempt to display the items even if UpdateItem hasn't started yet
					item.Value.Ready = false;
					updateQueue.Enqueue(item.Key);
				}
			}

			if (!updateQueue.TryPeek(out var _)) {
				// queue is empty
				return;
			}

			itemTreeView.QueueDraw();
			Task.Factory.StartNew(ProcessUpdateQueue);
		}

		/// <summary>
		///   updates the selection view, displaying the id, name, etc. for the currently selected item.
		/// </summary>
		private void UpdateSelectionView() {
			// get the currently selected item
			var item = selectedItem;
			var infobox = (Box) builder.GetObject("SelectionInfoBox");

			if (item == null) {
				selectionViewBox.Sensitive = false;
				infobox.Visible = false;
				((Label) builder.GetObject("LabelSelectedName")).Text = "buypeeb";
				return;
			}

			selectionViewBox.Sensitive = item.Ready;
			infobox.Visible = true;

			var lastUpdated = item.LastUpdated.ToLocalTime().ToString("MMM dd, HH:mm:ss");
			var info = new Dictionary<string, string> {
				{"Name", item.name},
				{"YahooName", item.originalName},
				{"Price", item.priceJpy},
				{"PriceAUD", item.priceAud},
				{"Ending", "Please wait..."},
				{"Bids", $"{item.Bids}"},
				{"BuyItNow", item.WinPrice == 0 ? "No" : $"{item.winPriceJpy} ({item.winPriceAud})"},
				{"AutoExtension", item.AutoExtension ? "Yes" : "No"}, {
					"LastUpdated",
					item.UpdateFailed
						? $"Failed to update item on {lastUpdated}"
						: $"Last updated: {(item.Ready ? lastUpdated : "Right now!")}"
				},
			};

			foreach (var (key, value) in info) {
				((Label) builder.GetObject($"LabelSelected{key}")).Text = value;
			}

			UpdateSelectionEndTime();

			var noteBuffer = (TextBuffer) builder.GetObject("TextBufferSelectedNotes");
			noteBuffer.Clear();
			if (!string.IsNullOrWhiteSpace(item.notes)) {
				noteBuffer.Text = item.notes;
			}

			((ToggleButton) builder.GetObject("ButtonSelectedFavourite")).Active = item.favourite;
		}

		/// <summary>
		///   opens a URL in the user's browser.
		/// </summary>
		/// <param name="url">the url to open</param>
		private static void OpenUrl(string url) {
			var psi = new ProcessStartInfo {
				FileName = url,
				UseShellExecute = true,
			};
			Process.Start(psi);
		}

		/// <summary>
		///   a simple MessageDialog constructor.
		/// </summary>
		/// <param name="message">the MessageDialog's format</param>
		/// <param name="buttonsType">the MessageDialog's bt</param>
		/// <returns></returns>
		private MessageDialog MsgBox(string message, ButtonsType buttonsType = ButtonsType.OkCancel) {
			var md = new MessageDialog(
				this,
				DialogFlags.DestroyWithParent | DialogFlags.Modal,
				MessageType.Question,
				buttonsType,
				message
			) {KeepAbove = true, Resizable = false, FocusOnMap = true, Title = "Buypeeb"};

			return md;
		}

		/// <summary>
		///   show a simple entry dialogue that allows the user to enter text and either cancel or submit it.
		/// </summary>
		/// <param name="title">the title of the entry dialogue</param>
		/// <param name="message">the prompt that should be presented to the user</param>
		/// <param name="prefill">a string to prefill the input box with</param>
		/// <returns></returns>
		private (bool accepted, string response) EntryDialogue(
			string title = "Buypeeb", string message = "Hi there!", string prefill = null
		) {
			var ed = new Dialog(
				title,
				this,
				DialogFlags.DestroyWithParent | DialogFlags.Modal,
				/* button_data: */ "Cancel", ResponseType.Cancel, "OK", ResponseType.Ok
			) {DefaultResponse = ResponseType.Ok, KeepAbove = true};


			var edLabel = new Label(message);
			var edEntry = new Entry();
			if (!string.IsNullOrWhiteSpace(prefill)) {
				edEntry.Text = prefill;
			}

			edEntry.ActivatesDefault = true;

			ed.ContentArea.PackStart(edLabel, true, true, 2);
			edLabel.Show();
			ed.ContentArea.PackStart(edEntry, true, true, 10);
			edEntry.Show();

			ed.ContentArea.MarginBottom = 5;
			ed.ContentArea.MarginTop = 5;
			ed.ContentArea.MarginStart = 5;
			ed.ContentArea.MarginEnd = 5;
			ed.MarginBottom = 5;

			var accepted = (ResponseType) ed.Run();
			var response = edEntry.Text;
			ed.Dispose();
			return (accepted == ResponseType.Ok, response);
		}

		/// <summary>
		///   gets the sort type selected by the user - "NameDescending", "EndingAscending", etc.
		/// </summary>
		/// <returns>the id of the radiobutton without the "Sort" prefix</returns>
		private string GetSortType() {
			foreach (var name in new List<string> {
				"NameDescending", "NameAscending", "PriceDescending", "PriceAscending", "EndingDescending", "EndingAscending",
			}) {
				var radio = (RadioMenuItem) builder.GetObject($"Sort{name}");
				if (radio.Active) {
					return name;
				}
			}

			return "NameAscending";
		}

		/// <summary>
		///   clears the treeview's liststore and adds everything in the watchlist to it, obeying sort order. tries to
		///   reselect the item that the user had selected, if possible.
		/// </summary>
		private void RenderList() {
			string id = null;
			if (selectedItem != null) {
				id = selectedItem.id;
			}

			items.Clear();
			var values = settings.watchlist.Values;
			var type = GetSortType();
			var sorted = type switch {
				"NameDescending" => values.OrderByDescending(item => item.name),
				"NameAscending" => values.OrderBy(item => item.name),
				"PriceDescending" => values.OrderByDescending(item => item.Price),
				"PriceAscending" => values.OrderBy(item => item.Price),
				"EndingDescending" => values.OrderByDescending(item => item.endDate),
				_ => values.OrderBy(item => item.endDate),
			};

			if (settings.showFavouritesAtTopOfList) {
				foreach (var item in sorted.Where(item => item.favourite)) {
					items.AppendValues(item);
				}

				foreach (var item in sorted.Where(item => !item.favourite)) {
					items.AppendValues(item);
				}
			} else {
				foreach (var item in sorted) {
					items.AppendValues(item);
				}
			}

			((TreeModelFilter) itemTreeView.Model).Refilter();

			if (id == null) {
				return;
			}

			// attempt to reselect the item we were just looking at
			// ReSharper disable once UseDeconstruction
			var pathAndIter = GetRow(id);
			if (pathAndIter.path != null) {
				itemTreeView.Selection.SelectPath(pathAndIter.path);
			}
		}

		// event handlers

		private void ButtonAddClicked(object sender, EventArgs a) {
			// Console.WriteLine("ButtonAddClicked");
			var aid = new AddItemDialogue {Title = "Buypeeb"};
			aid.Run();
			var url = aid.entryURL.Text;
			var name = aid.entryName.Text;
			aid.Dispose();

			// vry simpl url validation for simpol creachers
			// TODO: better. do better.
			var rx = new Regex(@"^http.+yahoo.+");
			if (rx.IsMatch(url)) {
				UpdateItem(settings.Watch(url, name).id, true);
				RenderList();
			} else {
				var md = MsgBox($"\"{url}\" is not a valid Buyee or Yahoo! Auctions Japan URL.", ButtonsType.Ok);
				md.Run();
				md.Dispose();
			}
		}

		private void ButtonUpdateAllClicked(object sender, EventArgs a) {
			UpdateItems();
		}

		private void ButtonClearEndedClicked(object sender, EventArgs a) {
			var md = MsgBox("Are you sure you want to remove all ended auctions from the list?");
			var r = (ResponseType) md.Run();
			md.Dispose();
			if (r != ResponseType.Ok) {
				return;
			}

			var removeMe = new List<string>();
			foreach (var (key, value) in settings.watchlist) {
				if (!value.Available) {
					removeMe.Add(key);
				}
			}

			foreach (var id in removeMe) {
				settings.watchlist.Remove(id);
			}

			RenderList();
		}

		private void ButtonClearAllClicked(object sender, EventArgs a) {
			var md = MsgBox("Are you sure you want to clear ALL items?");
			if (md.Run() == (int) ResponseType.Ok) {
				settings.watchlist.Clear();
				RenderList();
			}

			md.Dispose();
		}

		private void ButtonOpenClicked(object sender, EventArgs a) {
			var od = new FileChooserDialog(
				"Open userdata.json",
				this,
				FileChooserAction.Open,
				"Cancel", ResponseType.Cancel, "Open", ResponseType.Accept
			);

			var odf = new FileFilter {Name = "JSON files"};
			odf.AddMimeType("application/json");
			odf.AddPattern("*.json");
			od.AddFilter(odf);

			if (od.Run() == (int) ResponseType.Accept) {
				try {
					var j = File.ReadAllText(od.Filename);
					settings = JsonSerializer.Deserialize<Settings>(j);
					RenderList();
					UpdateItems();
				} catch (Exception e) {
					Console.WriteLine(e);
					var md = MsgBox($"Failed to load {od.Filename}!\n{e.Message}", ButtonsType.Ok);
					md.Run();
					md.Dispose();
				}
			}

			od.Dispose();
		}

		private void ButtonSaveClicked(object sender, EventArgs a) {
			SaveSettings();
		}

		private void ButtonSaveAsClicked(object sender, EventArgs a) {
			var sd = new FileChooserDialog(
				"Save userdata.json",
				this,
				FileChooserAction.Save,
				"Cancel", ResponseType.Cancel, "Save", ResponseType.Accept
			) {CurrentName = "userdata.json"};

			var sdf = new FileFilter {Name = "JSON files"};
			sdf.AddMimeType("application/json");
			sdf.AddPattern("*.json");
			sd.AddFilter(sdf);

			if (sd.Run() == (int) ResponseType.Accept) {
				try {
					if (!File.Exists(sd.Filename)) {
						using var fs = File.CreateText(sd.Filename);
						fs.Write(JsonSerializer.Serialize(settings, jsonOptions));
					}
				} catch (Exception e) {
					Console.WriteLine(e);
					var md = MsgBox($"Failed to write {sd.Filename}!\n{e.Message}.", ButtonsType.Ok);
					md.Run();
					md.Dispose();
				}
			}

			sd.Dispose();
		}

		private void ButtonExportClicked(object sender, EventArgs a) {
			var readyQuery = from item in settings.watchlist.Values.ToList() where !item.Ready select item;

			if (readyQuery.Count() != 0) {
				var md = MsgBox("Please wait for all items to update before exporting a CSV.", ButtonsType.Ok);
				md.Run();
				md.Dispose();
				return;
			}

			var sd = new FileChooserDialog(
				"Export watchlist as CSV",
				this,
				FileChooserAction.Save,
				"Cancel", ResponseType.Cancel, "Save", ResponseType.Accept
			) {CurrentName = "buypeeb.csv"};

			var sdf = new FileFilter {Name = "CSV files"};
			sdf.AddMimeType("text/csv");
			sdf.AddPattern("*.csv");
			sd.AddFilter(sdf);

			if (sd.Run() == (int) ResponseType.Accept) {
				try {
					using var writer = new StreamWriter(sd.Filename);
					using var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
					csv.WriteRecords(settings.watchlist);
				} catch (Exception e) {
					Console.WriteLine(e);
					var md = MsgBox($"Failed to write {sd.Filename}!\n{e.Message}.", ButtonsType.Ok);
					md.Run();
					md.Dispose();
				}
			}

			sd.Dispose();
		}

		private void ButtonHelpClicked(object sender, EventArgs args) {
			Console.WriteLine("Watchlist:");
			foreach (var item in settings.watchlist) {
				Console.WriteLine(item);
			}

			Console.WriteLine("---\nFilter results:");
			foreach (var item in filterQuery) {
				Console.WriteLine(item);
			}

			Console.WriteLine("---\nListstore contents:");
			foreach (object[] item in items) {
				Console.WriteLine(item[0]);
			}
		}

		private void ButtonQuitClicked(object sender, EventArgs a) {
			var md = MsgBox("Are you sure you want to quit?");

			var response = (ResponseType) md.Run();
			md.Dispose();
			if (response == ResponseType.Ok) {
				SaveSettings();
				Application.Quit();
			}
		}

		private void ButtonSettingsClicked(object sender, EventArgs args) {
			var win = new SettingsWindow(settings);
			Application.AddWindow(win);
			win.DeleteEvent += WindowSettingsClosed;
			win.Show();
		}

		private void TreeViewItemsSelectionChanged(object sender, EventArgs a) {
			UpdateSelectionView();
		}

		private void ButtonViewBuyeeClicked(object sender, EventArgs a) {
			OpenUrl(selectedItem.buyeeUrl);
		}

		private void ButtonViewYahooClicked(object sender, EventArgs a) {
			OpenUrl(selectedItem.url);
		}

		private void ButtonSelectedRemoveClicked(object sender, EventArgs a) {
			var item = selectedItem;

			var md = MsgBox($"Are you sure you want to remove the item \"{item.name}\"?");

			var response = (ResponseType) md.Run();
			md.Dispose();
			if (response == ResponseType.Ok) {
				settings.watchlist.Remove(item.id);
				RenderList();
			}
		}

		private void ButtonSelectedRenameClicked(object sender, EventArgs a) {
			var item = selectedItem;
			var (accepted, response) = EntryDialogue(
				"Rename item", $"Enter a new name for the item \"{item.name}\".", item.name
			);

			if (accepted) {
				item.name = response;
				UpdateSelectionView();
			}
		}

		private void ButtonSelectedUpdateClicked(object sender, EventArgs args) {
			selectionViewBox.Sensitive = false;
			if (updateQueue.Contains(selectedItem.id)) {
				// the item is already waiting to be updated
				return;
			}

			UpdateItem(selectedItem.id);
		}

		private void ButtonSelectedFavouriteToggled(object sender, EventArgs args) {
			var s = (ToggleButton) sender;
			selectedItem.favourite = s.Active;

			if (settings.showFavouritesAtTopOfList) {
				RenderList();
			} else {
				// i don't know why this is necessary
				var pathAndIter = GetRow(selectedItem.id);
				if (pathAndIter.path != null) {
					items.EmitRowChanged(pathAndIter.path, pathAndIter.iter);
				}
			}
		}

		private void ButtonSelectedNotesClearClicked(object sender, EventArgs args) {
			var item = selectedItem;
			var md = MsgBox($"Are you sure you want to clear the notes for \"{item.name}\"?");
			if (md.Run() == (int) ResponseType.Ok) {
				var noteBuffer = (TextBuffer) builder.GetObject("TextBufferSelectedNotes");
				noteBuffer.Clear();
				selectedItem.notes = null;
			}

			md.Dispose();
		}

		private void TextViewSelectedNotesFocusOut(object sender, FocusOutEventArgs args) {
			// the "save" button does nothing, however, when you click the save button, you transfer focus to it, firing this
			// event!
			// how very sneaky
			var noteBuffer = (TextBuffer) builder.GetObject("TextBufferSelectedNotes");
			if (selectedItem != null) {
				selectedItem.notes = string.IsNullOrWhiteSpace(noteBuffer.Text) ? null : noteBuffer.Text;
			}
		}

		private void SortMenuClosed(object sender, EventArgs args) {
			RenderList();
		}

		private void WindowSettingsClosed(object sender, EventArgs args) {
			RenderList();
		}

		// timers

		/// <summary>
		///   updates the end time displayed in the selection box. runs every second to update the countdown timer.
		/// </summary>
		/// <returns>true</returns>
		private bool UpdateSelectionEndTime() {
			if (!selectionViewBox.IsSensitive) {
				return true;
			}

			var item = selectedItem;
			if (!item.Ready) {
				return true;
			}

			var ending = "";
			if (item.Available) {
				var now = DateTime.Now;
				var end = item.endDate.ToLocalTime();
				var span = end.Subtract(now);

				if (span.Days > 0) {
					ending += span.ToString("dd' days, '"); // will format twelve days as "12 days, "
				}

				// timespan objects don't contain definitions for the time or date separators, so the colons need to be escaped
				// `HH` doesn't exist, but `hh` behaves identically
				// see https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings
				ending += span.ToString(@"hh\:mm\:ss");
			} else {
				ending = "Auction has ended";
			}

			endingLabel.Text = ending;
			return true;
		}

		/// <summary>
		///   updates all items that need updating. runs every ten seconds.
		/// </summary>
		/// <returns>true</returns>
		private bool AutoUpdateItems() {
			if (queueActive) {
				// don't autoupdate if the queue is active
				return true;
			}

			foreach (var item in outdatedItemQuery) {
				updateQueue.Enqueue(item.id);
			}

			if (updateQueue.TryPeek(out var _)) {
				// there's at least one item in the queue
				ProcessUpdateQueue();
			}

			return true;
		}

		// column renderers

		private static void RenderColumnFavourite(
			TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter
		) {
			var item = (YahooAuctionsItem) model.GetValue(iter, 0);
			((CellRendererText) cell).Text = item.favourite ? "♥" : "";
		}

		private static void RenderColumnName(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter) {
			var item = (YahooAuctionsItem) model.GetValue(iter, 0);
			((CellRendererText) cell).Text = item.name ?? "Loading...";
		}

		private static void RenderColumnPriceYen(
			TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter
		) {
			var item = (YahooAuctionsItem) model.GetValue(iter, 0);
			((CellRendererText) cell).Text = item.Ready ? item.priceJpy : "...";
		}

		private static void RenderColumnPriceAUD(
			TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter
		) {
			var item = (YahooAuctionsItem) model.GetValue(iter, 0);
			((CellRendererText) cell).Text = item.Ready ? item.priceAud : "...";
		}

		private void RenderColumnEnding(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter) {
			var item = (YahooAuctionsItem) model.GetValue(iter, 0);
			var ending = "";
			if (item.Ready) {
				if (!item.Available) {
					ending = "Ended";
				} else {
					var now = DateTime.Now;
					var end = item.endDate.ToLocalTime();
					// TODO: should we show the year if the auction ends next year? 0uo
					if (end.DayOfYear != now.DayOfYear) {
						// the auction isn't ending today, so we should show the day it's ending on for clarity
						ending += end.ToString("MMM d ");
					}

					ending += end.ToString("HH:mm");
					if (settings.showSecondsInListView) {
						// add the seconds on to the end
						ending += end.ToString(":ss");
					}
				}
			}

			((CellRendererText) cell).Text = item.Ready ? ending : "...";
		}

		// tree filter

		private bool ItemFilter(ITreeModel model, TreeIter iter) {
			var item = (YahooAuctionsItem) model.GetValue(iter, 0);
			if (item == null) {
				return true;
			}

			if (item.Price == 0) {
				// the item has only just been added, so we can't compare it against the filters, since it's missing most of its data
				return true;
			}

			bool Filtered(string name) {
				return filterChecks[name].Active;
			}

			// first, check to see if any filters are set that would exclude everything, such as hiding both active and ended auctions
			// if so, there's no need to run the more expensive linq query
			if (
				Filtered("Favourites") && Filtered("NonFavourites") ||
				Filtered("Active") && Filtered("Ended") ||
				Filtered("EndingToday") && Filtered("EndingAfterToday") ||
				Filtered("WithWinPrice") && Filtered("WithNoWinPrice")
			) {
				return false;
			}

			return filterQuery.Contains(item);
		}

		private void RunFilter(object sender, EventArgs a) {
			((TreeModelFilter) itemTreeView.Model).Refilter();
		}
	}
}