/core/src/App/Server.zig at f8d353fc96fb7d58c9f3af2e9f19467264863df8

// 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

const std = @import("std");

const callback = @import("./callback.zig");
const connection = @import("../roon/connection.zig");
const Transport = @import("../roon/services/transport.zig").TransportService;
pub const Zone = @import("./Server/Zone.zig");

const Self = @This();

const Zones = std.StringHashMap(Zone.CApi);
const OnZoneAdd = callback.Callback(*const Zone.CApi);
const OnZoneListLoadingChange = callback.Callback(struct {});

allocator: std.mem.Allocator,
address: std.net.Address,
pool: *std.Thread.Pool,
zones: Zones,
on_zone_add: OnZoneAdd.Store,
on_zone_list_loading_change: OnZoneListLoadingChange.Store,

// Unowned. Caller manages the resource.
conn: *connection.Connection,

// Unowned. Caller manages the resource.
capi_lock: *std.Thread.Mutex,

fn deinit(self: *Self) void {
    var iter = self.zones.iterator();
    while (iter.next()) |entry| {
        entry.value_ptr.deinit(self.allocator);
        self.allocator.free(entry.key_ptr.*);
    }
    self.zones.deinit();

    self.on_zone_add.deinit();
    self.on_zone_list_loading_change.deinit();
}

pub const CApi = extern struct {
    internal: *Self,
    id: [*:0]const u8,
    id_len: usize,
    name: [*:0]const u8,
    name_len: usize,
    version: [*:0]const u8,
    version_len: usize,
    // Each element is a reference to an item in `internal.zones`.
    zones: [*]*Zone.CApi,
    zones_len: usize,
    zones_loading: ZoneListLoading = .not_loaded,
    token: [*:0]const u8,
    token_len: usize,

    pub const ZoneListLoading = enum(c_int) {
        not_loaded = 0,
        loading = 1,
        loaded = 2,
        refreshing = 3,
        err_unexpected = 4,
        err_thread_spawn = 5,
        err_out_of_memory = 6,
        err_non_success = 7,
    };

    pub fn init(
        allocator: std.mem.Allocator,
        address: std.net.Address,
        conn: *connection.Connection,
        id: []const u8,
        name: []const u8,
        version: []const u8,
        token: []const u8,
        pool: *std.Thread.Pool,
        capi_lock: *std.Thread.Mutex,
    ) std.mem.Allocator.Error!CApi {
        const internal = try allocator.create(Self);
        errdefer allocator.destroy(internal);
        internal.* = .{
            .allocator = allocator,
            .address = address,
            .conn = conn,
            .pool = pool,
            .capi_lock = capi_lock,
            .zones = Zones.init(allocator),
            .on_zone_add = OnZoneAdd.Store.init(allocator),
            .on_zone_list_loading_change = OnZoneListLoadingChange.Store.init(allocator),
        };
        errdefer internal.deinit();

        const id_z = try allocator.dupeZ(u8, id);
        errdefer allocator.free(id_z);

        const name_z = try allocator.dupeZ(u8, name);
        errdefer allocator.free(name_z);

        const version_z = try allocator.dupeZ(u8, version);
        errdefer allocator.free(version_z);

        const token_z = try allocator.dupeZ(u8, token);
        errdefer allocator.free(token_z);

        return CApi{
            .internal = internal,
            .id = id_z.ptr,
            .id_len = id_z.len,
            .name = name_z.ptr,
            .name_len = name_z.len,
            .version = version_z.ptr,
            .version_len = version_z.len,
            .zones = undefined,
            .zones_len = 0,
            .token = token_z,
            .token_len = token_z.len,
        };
    }

    pub fn deinit(self: *CApi) void {
        self.internal.allocator.free(self.zones[0..self.zones_len]);
        self.internal.allocator.free(self.token[0..self.token_len]);
        self.internal.allocator.free(self.version[0..self.version_len]);
        self.internal.allocator.free(self.name[0..self.name_len]);
        self.internal.allocator.free(self.id[0..self.id_len]);
        self.internal.deinit();
        self.internal.allocator.destroy(self.internal);
        self.internal = undefined;
    }

    pub fn loadZones(capi_ptr: ?*CApi) callconv(.C) void {
        const capi = capi_ptr orelse return;
        if (capi.zones_loading == .loading or capi.zones_loading == .refreshing) {
            std.log.debug("Zone list is already loading, skipping `loadZones`", .{});
            return;
        }

        std.log.debug("Loading list of zones...", .{});
        capi.zones_loading = if (capi.zones_loading == .not_loaded) .loading else .refreshing;

        capi.internal.pool.spawn(loadZonesWorker, .{capi}) catch |err| {
            std.log.err("Failed to spawn thread for loading zones: {s}", .{@errorName(err)});
            capi.zones_loading = .err_thread_spawn;

            capi.internal.on_zone_list_loading_change.runAll(.{});
            return;
        };
    }

    fn loadZonesWorker(self: *CApi) void {
        self.loadZonesWorkerInnerCont() catch |err| {
            std.log.err("Failed to subscribe to zone status: {s}", .{@errorName(err)});
            self.zones_loading = switch (err) {
                error.OutOfMemory => ZoneListLoading.err_out_of_memory,
                else => ZoneListLoading.err_unexpected,
            };

            self.internal.on_zone_list_loading_change.runAll(.{});
        };
    }

    fn loadZonesWorkerInnerCont(self: *CApi) !void {
        var subscription = Transport.ZoneChangeSubscription.init(self.internal.conn);

        var iter = try subscription.iter(self.internal.allocator);
        while (try iter.next(self.internal.allocator)) |event| {
            defer event.deinit();

            self.internal.capi_lock.lock();
            defer self.internal.capi_lock.unlock();

            for (event.added_zones) |zone| {
                std.log.debug(
                    "Adding zone \"{s}\" ({s})...",
                    .{ zone.display_name, zone.zone_id },
                );

                const key = self.internal.zones.getKey(zone.zone_id) orelse try self.internal.allocator.dupe(u8, zone.zone_id);

                var prev = try self.internal.zones.fetchPut(
                    key,
                    try Zone.CApi.init(self.internal.allocator, &zone),
                );

                if (prev) |*entry| {
                    entry.value.deinit(self.internal.allocator);
                }
            }

            for (event.changed_zones) |zone| {
                std.log.debug(
                    "Replacing zone \"{s}\" ({s})...",
                    .{ zone.display_name, zone.zone_id },
                );

                const key = self.internal.zones.getKey(zone.zone_id) orelse try self.internal.allocator.dupe(u8, zone.zone_id);

                var prev = try self.internal.zones.fetchPut(
                    key,
                    try Zone.CApi.init(self.internal.allocator, &zone),
                );

                if (prev) |*entry| {
                    entry.value.deinit(self.internal.allocator);
                }
            }

            for (event.removed_ids) |id| {
                if (self.internal.zones.getEntry(id)) |entry| {
                    std.log.debug("Removing zone \"{s}\" ({s})...", .{
                        entry.value_ptr.name[0..entry.value_ptr.name_len],
                        id,
                    });

                    const key = entry.key_ptr.*;
                    entry.value_ptr.deinit(self.internal.allocator);

                    // The `if` conditional already checks whether the key exists.
                    _ = self.internal.zones.remove(id);

                    // `entry.key_ptr` changes at the call of `remove`.
                    // We have to store a pointer for the underlying buffer before that.
                    self.internal.allocator.free(key);
                }
            }

            const zones_len = self.internal.zones.count();
            const zones = try self.internal.allocator.alloc(*Zone.CApi, zones_len);

            var zone_iter = self.internal.zones.iterator();
            var i: usize = 0;
            while (zone_iter.next()) |entry| {
                zones[i] = entry.value_ptr;
                i += 1;
            }

            self.internal.allocator.free(self.zones[0..self.zones_len]);
            self.zones = zones.ptr;
            self.zones_len = zones.len;
            self.zones_loading = .loaded;

            self.internal.on_zone_list_loading_change.runAll(.{});
        }

        std.log.debug("Zone loading subscription finished", .{});
    }

    pub fn onZoneAdd(capi_ptr: ?*CApi, cb: OnZoneAdd.Fn, userdata: callback.UserData) callconv(.C) void {
        const capi = capi_ptr orelse return;
        // TODO: Notify error to caller
        capi.internal.on_zone_add.add(OnZoneAdd.init(cb, userdata)) catch {};
    }

    pub fn onZoneAddDisarm(capi_ptr: ?*CApi, cb: OnZoneAdd.Fn, userdata: callback.UserData) callconv(.C) void {
        const capi = capi_ptr orelse return;
        capi.internal.on_zone_add.remove(OnZoneAdd.init(cb, userdata));
    }

    pub fn onZoneListLoadingChange(capi_ptr: ?*CApi, cb: OnZoneListLoadingChange.Fn, userdata: callback.UserData) callconv(.C) void {
        const capi = capi_ptr orelse return;
        // TODO: Notify error to caller
        capi.internal.on_zone_list_loading_change.add(OnZoneListLoadingChange.init(cb, userdata)) catch {};
    }

    pub fn onZoneListLoadingChangeDisarm(capi_ptr: ?*CApi, cb: OnZoneListLoadingChange.Fn, userdata: callback.UserData) callconv(.C) void {
        const capi = capi_ptr orelse return;
        capi.internal.on_zone_list_loading_change.remove(OnZoneListLoadingChange.init(cb, userdata));
    }
};