1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120

// 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 clap = @import("clap");
const core = @import("core");

const State = @import("../State.zig");
const ExitCode = @import("../exit.zig").ExitCode;

const parser = .{
    .server_id = clap.parsers.string,
};

const params = clap.parseParamsComptime(
    \\-h, --help Prints this message to stdout and exits.
    \\<server_id>
    \\
);

pub fn run(allocator: std.mem.Allocator, iter: *std.process.ArgIterator) ExitCode {
    var diag = clap.Diagnostic{};
    var res = clap.parseEx(clap.Help, &params, parser, iter, .{
        .diagnostic = &diag,
        .allocator = allocator,
    }) catch |err| {
        diag.report(std.io.getStdErr().writer(), err) catch {};
        return ExitCode.incorrect_usage;
    };
    defer res.deinit();

    if (res.args.help > 0) {
        clap.help(std.io.getStdOut().writer(), clap.Help, &params, .{}) catch {
            return ExitCode.stdout_write_failed;
        };
        return ExitCode.ok;
    }

    const server_id: []const u8 = res.positionals[0] orelse {
        std.log.err("server_id is required", .{});
        clap.help(std.io.getStdErr().writer(), clap.Help, &params, .{}) catch {
            return ExitCode.stdout_write_failed;
        };
        return ExitCode.incorrect_usage;
    };
    const server_id_z = allocator.dupeZ(u8, server_id) catch {
        std.log.err("Unable to allocate memory for server ID (Out of memory)", .{});
        return ExitCode.out_of_memory;
    };
    defer allocator.free(server_id_z);

    const find_result = core.discovery.find(server_id_z.ptr) orelse {
        std.log.err("Unable to get server info: Out of memory", .{});
        return ExitCode.out_of_memory;
    };
    defer find_result.release();

    if (find_result.code != .ok) {
        std.log.err("Failed to get server info: {s}", .{@tagName(find_result.code)});
        return ExitCode.not_ok;
    }

    if (find_result.servers_len == 0) {
        std.log.err("Server not found for ID={s}", .{server_id});
        return ExitCode.not_ok;
    }

    const server = find_result.servers_ptr[0];

    const conn = core.connection.Connection.make(server, null) orelse {
        std.log.err("Unable to connect: Out of memory", .{});
        return ExitCode.out_of_memory;
    };
    defer conn.release();

    while (true) {
        const ev = conn.getEvent() orelse {
            std.log.err("Got empty event, terminating", .{});
            return ExitCode.not_ok;
        };
        defer ev.release();

        switch (ev.internal.payload) {
            .connection_error => |err_ev| {
                std.log.err("Failed to read event: {s}", .{@tagName(err_ev.code)});
                return ExitCode.not_ok;
            },
            .connected => |conn_ev| {
                const state = State{
                    .connection = .{
                        .server_id = server_id,
                        .token = std.mem.span(conn_ev.token),
                    },
                };

                state.write() catch |err| {
                    std.log.err("Failed to write state file: {s}", .{@errorName(err)});
                    return ExitCode.not_ok;
                };

                std.log.info("Connected to {s}", .{server.name});
                return ExitCode.ok;
            },
            else => {},
        }
    }
}