/gtk-adwaita/src/Application.vala at f3fa46a40da6b38662281273307383a9a41af9e6

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

namespace Plac {
public class App : Adw.Application {
	public App(){
		Object(
			application_id: "jp.pocka.plac.gtk-adwaita",
			flags : ApplicationFlags.DEFAULT_FLAGS
		);
	}

	protected override void activate() {
		var main_window = new ServerSelectorWindow(this);
		main_window.present();
	}

	public static int main(string[] args) {
		return new App().run(args);
	}
}

[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/generic-error-dialog.ui")]
class GenericErrorDialog : Adw.Dialog {
	[GtkChild]
	private unowned Gtk.Label description_label;

	[GtkChild]
	private unowned Gtk.Label details_label;

	public string description {
		get { return description_label.label; }
		set { description_label.label = value; }
	}
	public string details {
		get { return details_label.label; }
		set { details_label.label = value; }
	}

	public GenericErrorDialog() {
		Object();
	}
}

public errordomain ScanError {
	UNEXPECTED_ERROR,
	NETWORK_ERROR,
}

[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/server-list.ui")]
class ServerSelectorWindow : Adw.ApplicationWindow {
	[GtkChild]
	private unowned Gtk.ListBox servers_list;

	[GtkChild]
	private unowned Adw.Banner failure_banner;

	[GtkChild]
	private unowned Gtk.Stack stack;

	[GtkChild]
	private unowned Gtk.Button scan_button;

	[GtkChild]
	private unowned Adw.StatusPage empty;

	private ulong error_detail_hid;

	public ServerSelectorWindow(Gtk.Application app) {
		Object(application: app);
	}

	construct {
		scan_servers();

		var scan_action = new SimpleAction("scan_servers", null);
		scan_action.activate.connect(this.scan_servers);
		this.add_action(scan_action);
	}

	private void scan_servers() {
		failure_banner.revealed = false;
		if (error_detail_hid > 0) {
			failure_banner.disconnect(error_detail_hid);
			error_detail_hid = 0;
		}
		stack.visible_child_name = "loading";
		scan_button.set_sensitive(false);

		scan_servers_async.begin((_obj, res) => {
				try {
					var servers = scan_servers_async.end(res);

					servers_list.remove_all();

					if (servers.length == 0) {
						servers_list.visible = false;
						empty.visible = true;
						scan_button.add_css_class("suggested-action");
					} else {
						servers_list.visible = true;
						empty.visible = false;
						scan_button.remove_css_class("suggested-action");
					}

					foreach (unowned Plac.Server server in servers) {
						var row = new Adw.ActionRow();
						row.title = server.name;
						row.subtitle = server.version;

						var main_window = new MainWindow(this.application, server);
						row.activatable_widget = main_window;

						row.activated.connect(() => {
							main_window.start();
							main_window.present();
							this.close();
						});

						servers_list.append(row);
					}
				} catch (ScanError e) {
					// Have to capture, closure can't access `e` here (why? idk).
					var message = e.message;
					var is_network_error = e is ScanError.NETWORK_ERROR;

					scan_button.add_css_class("suggested-action");

					this.error_detail_hid = failure_banner.button_clicked.connect(() => {
						if (is_network_error) {
							var dialog = new ServerListNetworkErrorDialog(message);
							dialog.present(this);
						} else {
							var dialog = new ServerListUnexpectedErrorDialog(message);
							dialog.present(this);
						}
					});
					failure_banner.revealed = true;
				} finally {
					stack.visible_child_name = "idle";
					scan_button.set_sensitive(true);
				}
			});
	}

	private async Plac.Server[] scan_servers_async() throws ScanError {
		SourceFunc callback = scan_servers_async.callback;
		Plac.Server[] servers = {};
		Plac.ScanResultCode code = Plac.ScanResultCode.UNKNOWN_ERROR;

		ThreadFunc<void>run = () => {
			var opts = Plac.ScanOptions();
			opts.count = 4;
			opts.receive_window_ms = 1300;
			var scanner = new Plac.ServerScanner();
			var result = scanner.scan(opts);

			code = result.code;

			while (true) {
				var next = result.next();
				if (next == null) {
					Idle.add((owned) callback);
					return;
				}

				servers += (owned) next;
			}
		};

		new Thread<void>("server_scanner", (owned) run);
		yield;

		switch (code) {
		case Plac.ScanResultCode.OK:
			break;
		case Plac.ScanResultCode.NETWORK_UNAVAILABLE:
			throw new ScanError.NETWORK_ERROR("Network unavailable");
		case Plac.ScanResultCode.SOCKET_SETUP_ERROR:
		case Plac.ScanResultCode.TOO_MANY_SOCKET_ERROR:
			throw new ScanError.NETWORK_ERROR("Unable to setup UDP socket");
		case Plac.ScanResultCode.SOCKET_PERMISSION_ERROR:
			throw new ScanError.NETWORK_ERROR("No permission to open UDP socket");
		case Plac.ScanResultCode.UDP_RECV_ERROR:
			throw new ScanError.NETWORK_ERROR("Unable to receive UDP packet");
		case Plac.ScanResultCode.UDP_SEND_ERROR:
			throw new ScanError.NETWORK_ERROR("Unable to send UDP packet");
		case Plac.ScanResultCode.OUT_OF_MEMORY:
			throw new ScanError.UNEXPECTED_ERROR("Out of memory");
		case Plac.ScanResultCode.UNKNOWN_ERROR:
		case Plac.ScanResultCode.INVALID_RECEIVE_WINDOW:
		case Plac.ScanResultCode.NULL_POINTER_ARGS:
		default:
			throw new ScanError.UNEXPECTED_ERROR("Unexpected error");
		}

		return (owned) servers;
	}
}

[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/server-list-unexpected-error-dialog.ui")]
class ServerListUnexpectedErrorDialog : GenericErrorDialog {
	public ServerListUnexpectedErrorDialog(string details) {
		Object(details: details);
	}
}

[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/server-list-network-error-dialog.ui")]
class ServerListNetworkErrorDialog : GenericErrorDialog {
	public ServerListNetworkErrorDialog(string details) {
		Object(details: details);
	}
}

[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/main-window.ui")]
class MainWindow : Adw.ApplicationWindow {
	[GtkChild]
	private unowned Gtk.Label test_label;

	private Plac.Server server;
	private Plac.CoreApp app;

	public MainWindow(Gtk.Application app, Plac.Server server) {
		Object(application: app);
		this.server = server.dup();
	}

	// NOTE: `server` is `null` in `construct` block. Stupid constructor design forces
	//       manual memory management or ditching constructor. Here, I chose the latter
	//       because window is hidden by default and startup procedures should start
	//       once after the window became visible.
	public void start() {
		test_label.label = this.server.name;

		this.app = new Plac.CoreApp(this.server);
		if (this.app != null) {
			var result = this.app.connect(null);
			if (result.code != Plac.ConnectResultCode.OK) {
				stderr.printf("Unable to connect (%d)\n", result.code);
				return;
			}

			if (result.token == null) {
				stderr.printf("Connected, but got null token\n");
				return;
			}

			stderr.printf("Got token: %s\n", result.token);
		}
	}
}
}