/core/src/App/Server.zig at 1aa6eb97e68fe80c5ff68ac0d0c47c4d6e8a7438

// 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 OnZoneAdd = callback.Callback(*const Zone.CApi);
const OnZoneListLoadingChange = callback.Callback(struct {});

allocator: std.mem.Allocator,
address: std.net.Address,
on_zone_add: OnZoneAdd.Store,
on_zone_list_loading_change: OnZoneListLoadingChange.Store,

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

pub fn init(
    allocator: std.mem.Allocator,
    address: std.net.Address,
    conn: *connection.Connection,
) std.mem.Allocator.Error!Self {
    return .{
        .allocator = allocator,
        .address = address,
        .conn = conn,
        .on_zone_add = OnZoneAdd.Store.init(allocator),
        .on_zone_list_loading_change = OnZoneListLoadingChange.Store.init(allocator),
    };
}

pub fn deinit(self: *const Self) void {
    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,
    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,
    ) std.mem.Allocator.Error!CApi {
        const internal = try allocator.create(Self);
        errdefer allocator.destroy(internal);
        internal.* = try Self.init(allocator, address, conn);
        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 {
        const zones = self.zones[0..self.zones_len];
        for (zones) |zone| {
            zone.deinit(self.internal.allocator);
            self.internal.allocator.destroy(zone);
        }
        self.internal.allocator.free(zones);

        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;

        const thread = std.Thread.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;
        };
        thread.detach();
    }

    fn loadZonesWorker(self: *CApi) void {
        self.loadZonesWorkerInner() catch |err| {
            std.log.err("Failed to fetch list of zones: {s}", .{@errorName(err)});
            self.zones_loading = switch (err) {
                error.OutOfMemory => ZoneListLoading.err_out_of_memory,
                error.NonSuccessResponse => ZoneListLoading.err_non_success,
                else => ZoneListLoading.err_unexpected,
            };

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

    fn loadZonesWorkerInner(self: *CApi) !void {
        const res = try Transport.getZones(self.internal.allocator, self.internal.conn);
        defer res.deinit();

        const zones = try self.internal.allocator.alloc(*Zone.CApi, res.value.zones.len);
        errdefer self.internal.allocator.free(zones);

        for (res.value.zones, 0..) |zone, i| {
            const dst = try self.internal.allocator.create(Zone.CApi);
            errdefer self.internal.allocator.destroy(dst);

            dst.* = try Zone.CApi.init(self.internal.allocator, &zone);
            zones[i] = dst;
        }

        const prev = self.zones[0..self.zones_len];
        for (prev) |z| {
            z.deinit(self.internal.allocator);
            self.internal.allocator.destroy(z);
        }
        self.internal.allocator.free(prev);

        self.zones = zones.ptr;
        self.zones_len = zones.len;
        self.zones_loading = .loaded;

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

    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));
    }
};