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

// SPDX-FileCopyrightText: 2024 Shota FUJI <pockawoooh@gmail.com>
// SPDX-License-Identifier: AGPL-3.0-only

import gleam/dynamic
import gleam/result
import protobuf

fn decode_backend_result(
  input: dynamic.Dynamic,
  data: dynamic.Decoder(a),
  error: dynamic.Decoder(b),
) -> Result(Result(a, b), dynamic.DecodeErrors) {
  input
  |> dynamic.decode2(
    fn(ok, obj) {
      case ok {
        True ->
          obj
          |> dynamic.decode1(Ok, dynamic.field("data", data))

        False ->
          obj
          |> dynamic.decode1(Error, dynamic.field("error", error))
      }
    },
    dynamic.field("ok", dynamic.bool),
    dynamic.dynamic,
  )
  |> result.flatten
}

@external(javascript, "@/backend.ffi.ts", "loadWorker")
fn load_worker_internal(on_loaded: fn(dynamic.Dynamic) -> Nil) -> Nil

pub opaque type Worker {
  Worker(ref: dynamic.Dynamic)
}

pub type WorkerLoadError {
  DecodeError(dynamic.DecodeErrors)
  WorkerInitializeError(String)
}

pub fn load_worker(on_loaded: fn(Result(Worker, WorkerLoadError)) -> Nil) -> Nil {
  use backend_result <- load_worker_internal()

  backend_result
  |> decode_backend_result(
    dynamic.decode1(Worker, dynamic.dynamic),
    dynamic.decode1(WorkerInitializeError, dynamic.string),
  )
  |> result.map_error(DecodeError)
  |> result.flatten
  |> on_loaded
}

@external(javascript, "@/backend.ffi.ts", "request")
fn request_internal(
  worker: dynamic.Dynamic,
  service: String,
  method: String,
  request: protobuf.Binary,
  on_response: fn(protobuf.Binary) -> Nil,
) -> Nil

pub fn request(
  worker: Worker,
  service: String,
  method: String,
  request: protobuf.Binary,
  on_response: fn(protobuf.Binary) -> Nil,
) -> Nil {
  request_internal(worker.ref, service, method, request, on_response)
}