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

// Copyright 2025 Shota FUJI
//
// Licensed under the Zero-Clause BSD License or the Apache License, Version 2.0, at your option.
// You may not use, copy, modify, or distribute this file except according to those terms. You can
// find a copy of the Zero-Clause BSD License at LICENSES/0BSD.txt, and a copy of the Apache License,
// Version 2.0 at LICENSES/Apache-2.0.txt. You may also obtain a copy of the Zero-Clause BSD License
// at <https://opensource.org/license/0bsd> and a copy of the Apache License, Version 2.0 at
// <https://www.apache.org/licenses/LICENSE-2.0>
//
// SPDX-License-Identifier: 0BSD OR Apache-2.0

const std = @import("std");

/// A pair of key and value exist in a message.
pub const Property = struct {
    key: []const u8,
    value: []const u8,
};

pub const ParseError = error{
    /// Value of key size field is 0.
    EmptyKey,

    /// Key is not long enough indicated by size field.
    IncompleteKey,

    /// Key is not valid UTF-8 string.
    NonUTF8Key,

    /// Value size field is missing, or lacking a byte.
    InvalidValueSizeField,

    /// Value is not long enough indicated by size field.
    IncompleteValue,

    /// Value is not valid UTF-8 string.
    NonUTF8Value,
};

pub fn parseInto(bytes: []const u8, dst: *Property) ParseError!usize {
    var i: usize = 0;
    const key_size = bytes[i];
    i += 1;
    if (key_size == 0) {
        return ParseError.EmptyKey;
    }

    const key_start = i;
    i += key_size;
    if (i > bytes.len) {
        return ParseError.IncompleteKey;
    }
    const key = bytes[key_start..i];
    if (!std.unicode.utf8ValidateSlice(key)) {
        return ParseError.NonUTF8Key;
    }

    const value_size_start = i;
    i += 2;
    if (i > bytes.len) {
        return ParseError.InvalidValueSizeField;
    }
    const value_size = std.mem.readInt(
        u16,
        &.{ bytes[value_size_start], bytes[value_size_start + 1] },
        .big,
    );

    const value_start = i;
    i += value_size;
    if (i > bytes.len) {
        return ParseError.IncompleteValue;
    }
    const value = bytes[value_start..i];
    if (!std.unicode.utf8ValidateSlice(value)) {
        return ParseError.NonUTF8Value;
    }

    dst.key = key;
    dst.value = value;

    return i;
}