/src/Windows/MainWindow.vala at 94fb33546c278acd2e3768d0b4aeb6274dce8c6e

// 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 PlacGtkAdwaita {
	private errordomain ResolveError {
		CONNECTION_ERROR,
		SERVER_NOT_FOUND
	}

	private class ServerLocation : Object, Plac.WebSocketConnectable {
		public GLib.InetSocketAddress address { get; construct; }
		public uint16 http_port { get; construct; }

		public ServerLocation(GLib.InetSocketAddress address, uint16 http_port) {
			Object(address: address, http_port: http_port);
		}
	}

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

		[GtkChild]
		private unowned PlaybackToolbar playback_toolbar;

		[GtkChild]
		private unowned Adw.Banner error_banner;

		[GtkChild]
		private unowned Adw.Banner closed_banner;

		[GtkChild]
		private unowned Browse browse;

		[GtkChild]
		private unowned Gtk.ListBox browse_hierarchy;

		private Settings settings = new Settings();

		private Plac.Server? server = null;
		private Plac.ZonesModel? zones = null;

		private string server_id;

		public MainWindow(Gtk.Application app, Plac.Server server) {
			(typeof (Artwork)).ensure();
			(typeof (ServerConnecting)).ensure();
			(typeof (PlaybackToolbar)).ensure();

			Object(application: app);
			this.server = server;
			this.server_id = server.id;
		}

		public MainWindow.from_server_id(Gtk.Application app, string server_id) {
			(typeof (Artwork)).ensure();
			(typeof (ServerConnecting)).ensure();
			(typeof (PlaybackToolbar)).ensure();

			Object(application: app);
			this.server_id = server_id;
		}

		construct {
			var provider = new Gtk.CssProvider();
			provider.load_from_resource("/jp/pocka/plac/gtk-adwaita/css/main-window.css");
			Gtk.StyleContext.add_provider_for_display(
				this.display, provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
			);

			error_banner.button_clicked.connect(() => {
				connect_async.begin((_obj, res) => {
					connect_async.end(res);
				});
			});

			closed_banner.button_clicked.connect(() => {
				connect_async.begin((_obj, res) => {
					connect_async.end(res);
				});
			});

			var explore_row = new BrowseHierarchyRow(BROWSE, "Explore");
			browse_hierarchy.append(explore_row);
			browse_hierarchy.select_row(explore_row);

			browse_hierarchy.append(new BrowseHierarchyRow(ALBUMS, "Albums"));
			browse_hierarchy.append(new BrowseHierarchyRow(PLAYLISTS, "Playlists"));
			browse_hierarchy.append(new BrowseHierarchyRow(ARTISTS, "Artists"));
			browse_hierarchy.append(new BrowseHierarchyRow(GENRES, "Genres"));
			browse_hierarchy.append(new BrowseHierarchyRow(COMPOSERS, "Composers"));
			browse_hierarchy.append(new BrowseHierarchyRow(INTERNET_RADIO, "Internet Radio"));
			browse_hierarchy.append(new BrowseHierarchyRow(SETTINGS, "Settings"));

			browse_hierarchy.row_selected.connect((row) => {
				if (row == null) {
					return;
				}

				browse.hierarchy = ((BrowseHierarchyRow) row).hierarchy;
			});

			browse.loading_start.connect(() => {
				browse_hierarchy.sensitive = false;
			});

			browse.loading_end.connect(() => {
				browse_hierarchy.sensitive = true;
			});
		}

		public void start() {
			root_stack.visible_child_name = "loading";
			this.present();

			connect_async.begin((_obj, res) => {
				connect_async.end(res);
			});
		}

		private async void connect_async() {
			closed_banner.revealed = false;

			Plac.WebSocketConnectable dest;
			if (server != null) {
				dest = server;
			} else if (settings.connected_server_addr != "" && settings.connected_server_port > 0) {
				var ip_addr = settings.connected_server_addr;
				var port = settings.connected_server_port;

				var colon = ip_addr.index_of(":");
				var patched_ip_addr = colon < 0 ? ip_addr : ip_addr.slice(0, colon);
				var address = new GLib.InetSocketAddress.from_string(patched_ip_addr, port);
				dest = new ServerLocation(address, port);
			} else {
				try {
					dest = yield resolve_server_async();
				} catch (ResolveError error) {
					error_banner.title = error.message;
					error_banner.revealed = true;
					return;
				}
			}

			listen_async.begin(dest, (_obj, res) => {
				listen_async.end(res);
			});
		}

		private async Plac.Server resolve_server_async() throws ResolveError {
			GLib.SourceFunc callback = resolve_server_async.callback;
			Plac.Server? server = null;
			GLib.Error? error = null;

			var scanner = new Plac.ServerScanner();
			scanner.start();

			scanner.found.connect((found) => {
				if (server_id == found.id) {
					server = found;
					callback();
				}
			});

			scanner.scan_failed.connect((e) => {
				error = e;
			});

			yield;
			scanner.stop();

			if (error != null) {
				throw new ResolveError.CONNECTION_ERROR(error.message);
			}

			if (server == null) {
				throw new ResolveError.SERVER_NOT_FOUND(error.message);
			}

			return server;
		}

		private async void listen_async(Plac.WebSocketConnectable dest) {
			var token = settings.connected_server_token;

			root_stack.visible_child_name = "loading";
			playback_toolbar.visible = false;

			var req = new Roon.Registry.Register.Request();
			req.extension_id = Config.PLAC_APP_ID;
			req.display_name = "Plac for GTK";
			req.display_version = Config.PLAC_APP_VERSION;
			req.publisher = "Shota FUJI";
			req.email = "pockawoooh@gmail.com";
			if (token != null && token != "") {
				req.token = token;
			}
			req.required_services.append_val("com.roonlabs.transport:2");
			req.required_services.append_val("com.roonlabs.browse:1");
			req.provided_services.append_val("com.roonlabs.ping:1");

			try {
				var conn = yield Plac.Connection.connect_async(
					dest.address, dest.http_port, server_id, req
				);

				browse.sensitive = true;
				playback_toolbar.sensitive = true;

				conn.closed.connect(() => {
					GLib.log("Plac", LEVEL_INFO, "Connection closed.");
					browse.sensitive = false;
					playback_toolbar.sensitive = false;
					closed_banner.revealed = true;
				});

				this.server = conn.server;

				this.title = "Plac - %s".printf(server.name);

				zones = new Plac.ZonesModel(conn);

				root_stack.visible_child_name = "main";
				playback_toolbar.visible = true;

				settings.connected_server_id = server.id;
				settings.connected_server_token = conn.token;
				settings.connected_server_addr = server.address.address.to_string();
				settings.connected_server_port = server.http_port;

				playback_toolbar.conn = conn;
				playback_toolbar.zones_model = zones;
				browse.start(conn, zones);
			} catch (Plac.ConnectError error) {
				GLib.log("Plac", LEVEL_CRITICAL, "Failed to connect: %s", error.message);
				error_banner.title = "Connection error: %s".printf(error.message);
				error_banner.revealed = true;
			}
		}
	}
}