/src/Widgets/Browse.vala at d1962e17723897e700e2e8d640bc1b4140df9a96

// 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 BrowseWidgetLoadPageError {
		BROWSE_ERROR,
		LOAD_ERROR,
	}

	[GtkTemplate(ui = "/jp/pocka/plac/gtk-adwaita/ui/browse.ui")]
	class Browse : Gtk.Box {
		public signal void loading_start();
		public signal void loading_end();

		[GtkChild]
		private unowned Gtk.Label title;

		[GtkChild]
		private unowned Gtk.Label subtitle;

		[GtkChild]
		private unowned Gtk.Box loading;

		[GtkChild]
		private unowned Gtk.Button back;

		[GtkChild]
		private unowned Gtk.ListView items;

		[GtkChild]
		private unowned Gtk.ScrolledWindow scroller;

		[GtkChild]
		private unowned Adw.ToastOverlay toasts;

		private GLib.ListStore items_store = new GLib.ListStore(typeof (BrowseItem.Item));

		private Plac.Connection? conn = null;

		private BrowseItem.Item? item = null;

		private bool is_loading = false;
		private Settings settings = new Settings();

		public Roon.Browse.Hierarchy hierarchy { get; set; default = BROWSE; }
		public Plac.ZonesModel? zones_model { get; set; default = null; }
		public Roon.Transport.Zone? zone {
			owned get {
				if (zones_model == null || zones_model.zone == null) {
					return null;
				}

				return zones_model.zone;
			}
		}

		public Browse() {
			Object();
		}

		construct {
			this.notify["hierarchy"].connect(() => {
				this.item = null;
				load_page();
			});

			this.notify["zones-model"].connect(() => {
				if (zones_model != null) {
					zones_model.notify["zone"].connect(() => {
						this.item = null;
						load_page();
					});

					load_page();
				}
			});

			items.single_click_activate = true;
			items.model = new Gtk.NoSelection(items_store);

			var factory = new Gtk.SignalListItemFactory();
			factory.setup.connect(BrowseItem.setup_browse_item);
			factory.bind.connect(BrowseItem.bind_browse_item);
			items.factory = factory;

			items.activate.connect((position) => {
				var item = (BrowseItem.Item) items_store.get_item(position);
				if (item == null) {
					return;
				}

				this.item = item;
				load_page(false, false);
			});

			back.clicked.connect(() => {
				pop();
			});

			settings.settings.bind(Settings.SHOW_BROWSE_ITEM_SEPARATORS, items, "show-separators", GET);
		}

		public void start(Plac.Connection? conn, Plac.ZonesModel zones_model) {
			this.conn = conn;
			this.zones_model = zones_model;
			load_page();
		}

		private void start_loading() {
			is_loading = true;
			loading_start();
			loading.visible = true;
			this.sensitive = false;
		}

		private void end_loading() {
			is_loading = false;
			loading_end();
			loading.visible = false;
			this.sensitive = true;
		}

		private void pop(bool scroll_to_top = true) {
			this.item = null;
			this.load_page(true, scroll_to_top);
		}

		private void load_page(bool pop = false, bool scroll_to_top = true) {
			if (is_loading) {
				return;
			}

			if (conn == null) {
				GLib.log("Plac", LEVEL_WARNING, "Connection is null");
				return;
			}

			start_loading();

			load_page_async.begin(pop, scroll_to_top, (obj, res) => {
				try {
					load_page_async.end(res);
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_WARNING, "Failed to open a page: %s", error.message);
					var toast = new Adw.Toast.format("Failed to open a page: %s", error.message);
					toast.priority = HIGH;
					toasts.add_toast(toast);
				}

				end_loading();
			});
		}

		private async void load_page_async(bool pop, bool scroll_to_top) throws GLib.Error {
			var browse_req = new Roon.Browse.Browse.Request((Roon.Browse.Hierarchy) hierarchy);
			if (item != null) {
				browse_req.item_key = item.item.item_key;
			}
			if (zone != null) {
				browse_req.zone_or_output_id = zone.zone_id;
			}
			if (!pop && item == null) {
				browse_req.pop_all = true;
			}
			if (pop) {
				browse_req.pop_levels = 1;
			}

			var browse_res = yield browse_async(browse_req);

			if (browse_res.message != null) {
				var toast = new Adw.Toast(browse_res.message);
				toast.priority = NORMAL;
				toasts.add_toast(toast);
			}

			switch (browse_res.action) {
			case MESSAGE:
			case NONE:
				return;
			case REPLACE_ITEM:
			case REMOVE_ITEM:
				var action_name = browse_res.action.to_string();
				GLib.log(
					"Plac", LEVEL_CRITICAL,
					@"Roon server returned $(action_name) action, but Plac does not support the action."
				);
				return;
			case LIST:
				break;
			}

			if (browse_res.list == null) {
				throw new BrowseWidgetLoadPageError.BROWSE_ERROR(
					      "Roon server returned LIST action, but list property is empty."
				);
			}

			var load_req = new Roon.Browse.Load.Request(hierarchy);
			load_req.count = uint16.MAX;
			load_req.level = browse_res.list.level;

			var load_res = yield load_async(load_req);

			if (settings.label_parsing_enabled) {
				var parsed = new Plac.Label.Parsed.from_string(load_res.list.title);
				title.label = parsed.label;
			} else {
				title.label = load_res.list.title;
			}

			if (load_res.list.subtitle != null) {
				if (settings.label_parsing_enabled) {
					var parsed = new Plac.Label.Parsed.from_string(load_res.list.subtitle);
					subtitle.label = parsed.label;
				} else {
					subtitle.label = load_res.list.subtitle;
				}
				subtitle.visible = true;
			} else {
				subtitle.visible = false;
			}

			items_store.remove_all();
			if (scroll_to_top) {
				scroller.vadjustment.value = scroller.vadjustment.lower;
			}
			foreach (var new_item in load_res.items) {
				items_store.append(new BrowseItem.Item(new_item, conn));
			}

			back.visible = load_res.list.level > 0;
		}

		private async Roon.Browse.Browse.Response browse_async(Roon.Browse.Browse.Request request) throws GLib.Error {
			var res = yield conn.json_request("com.roonlabs.browse:1/browse", request.to_json());

			if (res.meta.service != "Success") {
				throw new BrowseWidgetLoadPageError.BROWSE_ERROR(@"Expected Success response, got $(res.meta.service).");
			}

			var body = new Moo.JsonBody.from_string(res.message, res.headers);
			return new Roon.Browse.Browse.Response.from_json(body.data);
		}

		private async Roon.Browse.Load.Response load_async(Roon.Browse.Load.Request request) throws GLib.Error {
			var res = yield conn.json_request("com.roonlabs.browse:1/load", request.to_json());

			if (res.meta.service != "Success") {
				throw new BrowseWidgetLoadPageError.BROWSE_ERROR(@"Expected Success response, got $(res.meta.service).");
			}

			var body = new Moo.JsonBody.from_string(res.message, res.headers);
			return new Roon.Browse.Load.Response.from_json(body.data);
		}
	}
}