buypeeb-cs/MainWindow.cs

/*
buypeeb - a program to track yahoo jp auctions of peebus.
Copyright (C) 2020 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.IO;
using System.Text.RegularExpressions;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using System.Net;
using System.Linq;
using System.Diagnostics;
using CsvHelper;
using Gtk;

namespace Buypeeb {
	class MainWindow : Window {

		private string location;
		private JsonSerializerOptions jsonOptions;

		private ListStore items;
		private Settings settings;
		private TreeView itemTreeView;
		private Builder builder;

		// TODO: whenever we get something from the builder, cache it for later
		// that way we don't need to constantly do "builder.GetObject"s
		// when that is done, you can use the cache array to replace everything from here...

		private Box selectionViewBox;
		private Label endingLabel;
		private bool queueActive;

		// ...to here.

		static SemaphoreSlim taskLimit = new SemaphoreSlim(6);
		private Queue<string> updateQueue = new Queue<string>();

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

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

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

		private MainWindow(Builder builder) : base(builder.GetObject("wndMain").Handle) {

			this.jsonOptions = new JsonSerializerOptions {
				Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All)
			};

			if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
				// C:\Users\Beebus\AppData\Roaming\Lynnear Software\buypeeb
				this.location = System.IO.Path.Combine(Environment.ExpandEnvironmentVariables("%APPDATA%"), "Lynnear Software", "buypeeb");
			}
			else {
				// ~/.config/Lynnear Software/buypeeb
				this.location = System.IO.Path.Combine(Environment.GetEnvironmentVariable("HOME"), ".config", "Lynnear Software", "buypeeb");
			}

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

			}
			else {
				this.settings = new Settings();
			}
			this.SaveSettings();
			this.Title = "Buypeeb";

			this.builder = builder;
			builder.Autoconnect(this);

			this.selectionViewBox = (Box)builder.GetObject("SelectionViewBox");
			this.endingLabel = (Label)builder.GetObject("LabelSelectedEnding");

			// bind treeview columns to watchlist instead of needing to manually sync its liststore
			this.itemTreeView = (TreeView)builder.GetObject("TreeViewItems");
			this.items = new ListStore(typeof(YahooAuctionsItem));
			this.RenderList();

			this.itemTreeView.Model = this.items;
			TreeCellDataFunc[] funcs = {
				new TreeCellDataFunc(this.RenderColumnFavourite),
				new TreeCellDataFunc(this.RenderColumnName),
				new TreeCellDataFunc(this.RenderColumnPriceYen),
				new TreeCellDataFunc(this.RenderColumnPriceAUD),
				new TreeCellDataFunc(this.RenderColumnEnding)
			};

			for (int i = 0; i < this.itemTreeView.Columns.Length; i++) {
				var c = this.itemTreeView.Columns[i];

				c.SetCellDataFunc(c.Cells[0], funcs[i]);
			}

			this.UpdateItems();
			GLib.Timeout.Add(1000, new GLib.TimeoutHandler(UpdateSelectionEndTime));

			DeleteEvent += WindowShutdown;
		}

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

		// general behaviour

		private (TreePath path, TreeIter iter) GetRow(string id) {
			// TODO: surely there's a better way to do this
			TreeIter iter;
			this.itemTreeView.Model.GetIterFirst(out iter);

			for (int i = 0; i < this.itemTreeView.Model.IterNChildren(); i++) {
				var x = (YahooAuctionsItem)this.itemTreeView.Model.GetValue(iter, 0);
				if (x.id == id) {
					return (this.itemTreeView.Model.GetPath(iter), iter);
				}
				else {
					this.itemTreeView.Model.IterNext(ref iter);
				}
			}

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

		private void SaveSettings() {
			string j = JsonSerializer.Serialize(this.settings, this.jsonOptions);
			string p = System.IO.Path.Combine(this.location, "userdata.json");
			Console.WriteLine(j);
			if (!Directory.Exists(this.location)) {
				Directory.CreateDirectory(this.location);
			}
			if (!File.Exists(p)) {
				var fs = File.CreateText(p);
				fs.Close();
			}
			File.WriteAllText(System.IO.Path.Combine(this.location, "userdata.json"), j);
		}

		private void UpdateThread(string id) {
			var item = this.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's currently stored
			item.ready = false;

			Gtk.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 pathAndIter = this.GetRow(id);
				this.items.EmitRowChanged(pathAndIter.path, pathAndIter.iter);
			});

			using (WebClient client = new WebClient()) {
				// TODO: download should have timeout
				// item.Update(client.DownloadString(item.url));
				Thread.Sleep(5000);
				item.Update(File.ReadAllText("yahoo.html"));
			}

			Gtk.Application.Invoke(delegate {
				var pathAndIter = this.GetRow(id);
				this.items.EmitRowChanged(pathAndIter.path, pathAndIter.iter);
				if (item == this.selectedItem) {
					// if the user has this item selected and it just became ready, enable the selection box
					this.selectionViewBox.Sensitive = true;
				}
			});

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

		private void ProcessUpdateQueue() {
			// recursively process the updatequeue
			// this is a BLOCKING FUNCTION
			this.queueActive = true;
			this.UpdateItem(this.updateQueue.Dequeue());
			if (this.updateQueue.TryPeek(out string _)) {
				this.ProcessUpdateQueue();
			}
			else {
				this.queueActive = false;
			}
		}

		private void UpdateItem(string id, bool evenIfAlreadyUpdating = false, bool force = false) {
			var item = this.settings.watchlist[id];
			if (item.updatedRecently && !force) {
				// the item has been updated recently, and force is not true
				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();
			var t = Task.Factory.StartNew(() => {
				this.UpdateThread(id);
			}).ContinueWith(task => { taskLimit.Release(); });
		}

		private void UpdateItems() {
			if (this.queueActive) {
				return;
			}

			this.selectionViewBox.Sensitive = false;
			foreach (var item in this.settings.watchlist) {
				if (!this.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;
					this.updateQueue.Enqueue(item.Key);
				}
			}

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

			this.itemTreeView.QueueDraw();
			var t = Task.Factory.StartNew(() => {
				this.ProcessUpdateQueue();
			});

		}

		private void UpdateSelectionView() {
			// get the currently selected item
			var item = this.selectedItem;
			var infobox = (Box)this.builder.GetObject("SelectionInfoBox");

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

			this.selectionViewBox.Sensitive = item.ready;
			infobox.Visible = true;

			var info = new Dictionary<string, string> {
				{ "Name", item.name },
				{ "YahooName", item.originalName },
				{ "Price", item.priceJPY },
				{ "PriceAUD", item.priceAUD },
				{ "Ending", "..." },
				{ "Bids", $"{item.bids}" },
				{ "BuyItNow", item.winPrice == 0 ? "No" : $"{item.winPriceJPY} ({item.winPriceAUD})" },
				{ "AutoExtension", item.autoExtension ? "Yes" : "No" },
				{ "LastUpdated", "Last updated: heeeenlo" }
			};

			foreach (var row in info) {
				var l = (Label)this.builder.GetObject($"LabelSelected{row.Key}");
				l.Text = row.Value;
			}

			var f = (ToggleButton)this.builder.GetObject("ButtonSelectedFavourite");
			f.Active = item.favourite;

		}
		private void OpenUrl(string url) {
			// https://github.com/dotnet/runtime/issues/17938
			if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
				ProcessStartInfo psi = new ProcessStartInfo {
					FileName = url,
					UseShellExecute = true
				};
				Process.Start(psi);
			}
			else {
				// let's hope you have xdg-open installed
				Process.Start("xdg-open", url);
			}
		}

		private MessageDialog MsgBox(string message, ButtonsType buttonsType = ButtonsType.OkCancel) {
			var md = new MessageDialog(
				parent_window: this,
				flags: DialogFlags.DestroyWithParent | DialogFlags.Modal,
				type: MessageType.Question,
				bt: buttonsType,
				format: message
			);
			md.KeepAbove = true;
			md.Resizable = false;
			md.FocusOnMap = true;
			md.Title = "Buypeeb";

			return md;
		}

		// show a simple entry dialogue that allows the user to enter text and either cancel or submit it
		private (Boolean accepted, string response) EntryDialogue(string title = "Buypeeb", string message = "Hi there!", string prefill = null) {
			Dialog ed = new Dialog(
				title: title,
				parent: this,
				flags: DialogFlags.DestroyWithParent | DialogFlags.Modal,
				/* button_data: */ "Cancel", ResponseType.Cancel, "OK", ResponseType.Ok
			);

			ed.DefaultResponse = ResponseType.Ok;
			ed.KeepAbove = true;

			Label edLabel = new Label(message);
			Entry 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;

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

		private void RenderList() {
			this.items.Clear();
			foreach (var item in this.settings.watchlist.Values) {
				items.AppendValues(item);
			}
		}

		// event handlers

		private void ButtonAddClicked(object sender, EventArgs a) {
			// Console.WriteLine("ButtonAddClicked");
			AddItemDialogue aid = new AddItemDialogue();
			aid.Title = "Buypeeb";
			ResponseType accepted = (ResponseType)aid.Run();
			string url = aid.GetURL();
			string name = aid.GetName();
			aid.Dispose();

			// vry simpl url validation for simpol creachers
			Regex rx = new Regex(@"^http.+yahoo.+");
			if (rx.IsMatch(url)) {
				Console.WriteLine("{0} will be added", url);
				this.UpdateItem(this.settings.Watch(url, name).id);
				this.RenderList();
			}
			else {
				Console.WriteLine("{0} is an invalid url", url);
			}
		}

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

		private void ButtonClearEndedClicked(object sender, EventArgs a) {
			Console.WriteLine("ButtonClearEndedClicked");
			var md = this.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 item in this.settings.watchlist) {
				if (!item.Value.available) {
					removeMe.Add(item.Key);
				}
			}

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

			this.RenderList();
		}

		private void ButtonClearAllClicked(object sender, EventArgs a) {
			Console.WriteLine("ButtonClearAllClicked");
		}

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

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

			if (od.Run() == (int)ResponseType.Accept) {
				try {
					string j = File.ReadAllText(od.Filename);
					this.settings = JsonSerializer.Deserialize<Settings>(j);
					this.RenderList();
					this.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) {
			this.SaveSettings();
		}

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

			var sdf = new FileFilter();
			sdf.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)) {
						var fs = File.CreateText(sd.Filename);
						fs.Close();
					}
					File.WriteAllText(sd.Filename, JsonSerializer.Serialize(this.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 this.settings.watchlist.Values.ToList() where !item.ready select item;
			foreach (var item in readyQuery) {
				Console.WriteLine(item.name);
			}

			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(
				title: "Export watchlist as CSV",
				parent: this,
				action: FileChooserAction.Save,
				"Cancel", ResponseType.Cancel, "Save", ResponseType.Accept
			);
			sd.CurrentName = "buypeeb.csv";

			var sdf = new FileFilter();
			sdf.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, System.Globalization.CultureInfo.InvariantCulture)) {
						csv.WriteRecords(this.settings.watchlist);
					}
				}
				catch (Exception e) {
					Console.WriteLine(e);
					MsgBox($"Failed to write {sd.Filename}!\n{e.Message}.", ButtonsType.Ok);
				}
			}

			sd.Dispose();
		}

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

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

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

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

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

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

			var md = this.MsgBox($"Are you sure you want to remove the item \"{item.name}\"?"); // TODO: this looks bad being all on one line

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

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

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

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

			// i don't know why this is necessary
			var pathAndIter = this.GetRow(this.selectedItem.id);
			this.items.EmitRowChanged(pathAndIter.path, pathAndIter.iter);
		}

		// timers

		private bool UpdateSelectionEndTime() {
			if (!this.selectionViewBox.IsSensitive) {
				return true;
			}

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

			string 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";
			}

			this.endingLabel.Text = ending;
			return true;
		}

		// column renderers

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

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

		private void RenderColumnPriceYen(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.ITreeModel model, Gtk.TreeIter iter) {
			YahooAuctionsItem item = (YahooAuctionsItem)model.GetValue(iter, 0);
			(cell as Gtk.CellRendererText).Text = item.ready ? item.priceJPY : "...";
		}

		private void RenderColumnPriceAUD(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.ITreeModel model, Gtk.TreeIter iter) {
			YahooAuctionsItem item = (YahooAuctionsItem)model.GetValue(iter, 0);
			(cell as Gtk.CellRendererText).Text = item.ready ? item.priceAUD : "...";
		}

		private void RenderColumnEnding(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.ITreeModel model, Gtk.TreeIter iter) {
			YahooAuctionsItem item = (YahooAuctionsItem)model.GetValue(iter, 0);
			string 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 (this.settings.displaySecondsInList) {
						// add the seconds on to the end
						ending += end.ToString(":ss");
					}
				}
			}
			(cell as Gtk.CellRendererText).Text = item.ready ? ending : "...";
		}
	}
}