load("//:build/kj_test.bzl", "kj_test")
load("//:build/wd_capnp_library.bzl", "wd_capnp_library")
load("//:build/wd_cc_embed.bzl", "wd_cc_embed")
load("//:build/wd_cc_library.bzl", "wd_cc_library")
load("//:build/wd_test.bzl", "wd_test")

# TODO(cleanup): Split up into smaller targets, although this target is already relatively small and
# not encumbered with many dependencies.
wd_cc_library(
    name = "io-helpers",
    srcs = [
        "io-thread-context.c++",
        "io-timers.c++",
        "request-tracker.c++",
    ],
    hdrs = [
        "io-thread-context.h",
        "io-timers.h",
        "request-tracker.h",
    ],
    visibility = ["//visibility:public"],
    deps = [
        "//src/workerd/jsg",
        "@capnp-cpp//src/capnp/compat:http-over-capnp",
    ],
)

wd_cc_library(
    name = "io",
    # HACK: Currently, the `io` and `api` packages are interdependent. We fold all the sources
    #   from `api` into `io`. In principle, it should be possible to pull them apart so `api`
    #   depends on `io` but not vice versa. In practice, this appears very difficult due to the
    # IoContext -> Worker -> ServiceWorkerGlobalScope -> (various api targets) dependency chain.
    # TODO(cleanup): Fix this.
    srcs = [
        "compatibility-date.c++",
        "external-pusher.c++",
        "features.c++",
        "hibernation-manager.c++",
        "io-channels.c++",
        "io-context.c++",
        "io-own.c++",
        "io-util.c++",
        "trace-stream.c++",
        "tracer.c++",
        "worker.c++",
        "worker-fs.c++",
    ] + ["//src/workerd/api:srcs"],
    hdrs = [
        "compatibility-date.h",
        "external-pusher.h",
        "hibernation-manager.h",
        "io-channels.h",
        "io-context.h",
        "io-own.h",
        "io-util.h",
        "trace-stream.h",
        "tracer.h",
        "worker.h",
        "worker-fs.h",
    ] + ["//src/workerd/api:hdrs"],
    implementation_deps = [
        "//src/rust/jsg",
        "//src/workerd/api:crypto-crc-impl",
        "//src/workerd/api:data-url",
        "//src/workerd/api/node:exceptions",
        "//src/workerd/util:completion-membrane",
        "//src/workerd/util:entropy",
        "//src/workerd/util:perfetto",
        "//src/workerd/util:string-buffer",
        "//src/workerd/util:strings",
        "//src/workerd/util:uuid",
        "@capnp-cpp//src/kj/compat:kj-brotli",
        "@capnp-cpp//src/kj/compat:kj-gzip",
        "@nbytes",
        "@simdutf",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":actor",
        ":actor-id",
        ":actor-storage_capnp",
        ":cdp_capnp",
        ":container_capnp",
        ":features",
        ":frankenvalue",
        ":io-gate",
        ":io-helpers",
        ":limit-enforcer",
        ":maximum-compatibility-date",
        ":observer",
        ":release-version",
        ":trace",
        ":wasm-instantiate-shim",
        ":worker-interface",
        ":worker-source",
        "//src/rust/cxx-integration",
        "//src/workerd/api:analytics-engine_capnp",
        "//src/workerd/api:deferred-proxy",
        "//src/workerd/api:encoding",
        "//src/workerd/api:fuzzilli",
        "//src/workerd/api:hibernation-event-params",
        "//src/workerd/api:url",
        "//src/workerd/jsg",
        "//src/workerd/jsg:inspector",
        "//src/workerd/jsg:script",
        "//src/workerd/util:checked-queue",
        "//src/workerd/util:exception",
        "//src/workerd/util:header-validation",
        "//src/workerd/util:immediate-crash",
        "//src/workerd/util:ring-buffer",
        "//src/workerd/util:small-set",
        "//src/workerd/util:sqlite",
        "//src/workerd/util:state-machine",
        "//src/workerd/util:strong-bool",
        "@capnp-cpp//src/capnp:capnp-rpc",
        "@capnp-cpp//src/capnp/compat:http-over-capnp",
        "@capnp-cpp//src/kj:kj-async",
        "@ncrypto",
        "@ssl",
    ],
)

# Headers only target to avoid having circular dependencies.
wd_cc_library(
    name = "features",
    hdrs = ["features.h"],
    implementation_deps = [
        "//src/workerd/jsg",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":compatibility-date_capnp",
    ],
)

wd_cc_library(
    name = "worker-modules",
    srcs = ["worker-modules.c++"],
    hdrs = ["worker-modules.h"],
    implementation_deps = [
        "//src/pyodide:pyodide_static",
        "//src/workerd/api:pyodide",
        "//src/workerd/api/node",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":io",
        "//src/pyodide:python-entrypoint",
        "//src/workerd/api:commonjs",
        "//src/workerd/api:rtti",
        "//src/workerd/jsg",
        "//src/workerd/util:strong-bool",
    ],
)

wd_cc_library(
    name = "bundle-fs",
    srcs = ["bundle-fs.c++"],
    hdrs = ["bundle-fs.h"],
    visibility = ["//visibility:public"],
    deps = [
        ":io",
    ],
)

wd_cc_library(
    name = "promise-wrapper",
    hdrs = ["promise-wrapper.h"],
    visibility = ["//visibility:public"],
    deps = [
        ":io",
        "//src/workerd/jsg",
    ],
)

wd_cc_library(
    name = "worker-source",
    hdrs = ["worker-source.h"],
    visibility = ["//visibility:public"],
    deps = [
        "//src/rust/cxx-integration",
        "@capnp-cpp//src/capnp",
    ],
)

# TODO(cleanup): Split this up further.
wd_cc_library(
    name = "actor",
    srcs = [
        "actor-cache.c++",
        "actor-sqlite.c++",
        "actor-storage.c++",
    ],
    hdrs = [
        "actor-cache.h",
        "actor-sqlite.h",
        "actor-storage.h",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":actor-storage_capnp",
        ":io-gate",
        ":trace",
        "//src/workerd/jsg:exception",
        "//src/workerd/util:duration-exceeded-logger",
        "//src/workerd/util:exception",
        "//src/workerd/util:sqlite",
        "//src/workerd/util:strong-bool",
        "@capnp-cpp//src/capnp:capnp-rpc",
        "@capnp-cpp//src/kj:kj-async",
    ],
)

wd_cc_library(
    name = "frankenvalue",
    srcs = ["frankenvalue.c++"],
    hdrs = ["frankenvalue.h"],
    visibility = ["//visibility:public"],
    deps = [
        ":frankenvalue_capnp",
        "//src/workerd/jsg",
        "@capnp-cpp//src/capnp:capnpc",
    ],
)

wd_cc_library(
    name = "trace",
    srcs = ["trace.c++"],
    hdrs = ["trace.h"],
    implementation_deps = [
        "//src/workerd/util:entropy",
        "//src/workerd/util:thread-scopes",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":trace_capnp",
        ":worker-interface_capnp",
        "//src/workerd/jsg:memory-tracker",
        "//src/workerd/util:own-util",
        "@capnp-cpp//src/capnp:capnp-rpc",
        "@capnp-cpp//src/capnp:capnpc",
        "@capnp-cpp//src/kj/compat:kj-http",
        "@ssl",
    ],
)

wd_cc_library(
    name = "observer",
    srcs = ["observer.c++"],
    hdrs = ["observer.h"],
    implementation_deps = [
        ":worker-interface",
        "//src/workerd/util:exception",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":features_capnp",
        ":trace",
        "//src/workerd/jsg:observer",
        "//src/workerd/util:sqlite",
    ],
)

wd_cc_library(
    name = "io-gate",
    srcs = ["io-gate.c++"],
    hdrs = ["io-gate.h"],
    visibility = ["//visibility:public"],
    deps = [
        ":trace",
        "@capnp-cpp//src/kj",
        "@capnp-cpp//src/kj:kj-async",
    ],
)

wd_cc_library(
    name = "limit-enforcer",
    srcs = ["tracked-wasm-instance.c++"],
    hdrs = [
        "limit-enforcer.h",
        "tracked-wasm-instance.h",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":outcome_capnp",
        "//src/workerd/jsg",
    ],
)

wd_cc_library(
    name = "worker-entrypoint",
    srcs = ["worker-entrypoint.c++"],
    hdrs = ["worker-entrypoint.h"],
    implementation_deps = [
        "//src/workerd/util:perfetto",
        "//src/workerd/util:strings",
    ],
    visibility = ["//visibility:public"],
    deps = [
        ":io",
    ],
)

wd_cc_library(
    name = "worker-interface",
    srcs = ["worker-interface.c++"],
    hdrs = ["worker-interface.h"],
    visibility = ["//visibility:public"],
    deps = [
        ":frankenvalue_capnp",
        ":trace",
        ":worker-interface_capnp",
        "//src/workerd/util",
        "@capnp-cpp//src/capnp:capnp-rpc",
        "@capnp-cpp//src/capnp:capnpc",
        "@capnp-cpp//src/capnp/compat:http-over-capnp",
    ],
)

wd_cc_library(
    name = "actor-id",
    hdrs = ["actor-id.h"],
    visibility = ["//visibility:public"],
    deps = ["@capnp-cpp//src/kj"],
)

genrule(
    name = "trimmed-release-version-gen",
    srcs = ["release-version.txt"],
    outs = ["trimmed-release-version.txt"],
    cmd = "tr -d '\n' < $(location release-version.txt) > $(location trimmed-release-version.txt)",
    cmd_ps = "(Get-Content $(location release-version.txt) -Raw -Encoding Ascii).TrimEnd() | Set-Content $(location trimmed-release-version.txt) -NoNewLine -Encoding Ascii",
    visibility = ["//visibility:public"],
)

genrule(
    name = "trimmed-maximum-compatibility-date-gen",
    srcs = ["maximum-compatibility-date.txt"],
    outs = ["trimmed-maximum-compatibility-date.txt"],
    cmd = "tr -d '\n' < $(location maximum-compatibility-date.txt) > $(location trimmed-maximum-compatibility-date.txt)",
    cmd_ps = "(Get-Content $(location maximum-compatibility-date.txt) -Raw -Encoding Ascii).TrimEnd() | Set-Content $(location trimmed-maximum-compatibility-date.txt) -NoNewLine -Encoding Ascii",
    visibility = ["//visibility:public"],
)

# The date of this release. Used for the version string and the npm compatibilityDate export.
wd_cc_embed(
    name = "release-version",
    src = ":trimmed-release-version.txt",
    base_name = "release-version",
)

# Maximum compatibility date that can safely be set using code compiled from this repo. Set to
# 7 days beyond the release date so that users can set their compat date to today even if
# they're running a workerd release from a few days ago.
#
# Note that the production Cloudflare Workers upload API always accepts any date up to the current
# date regardless of this constant, on the assumption that Cloudflare is always running the latest
# version of the code. This constant is more to protect users who are self-hosting the runtime and
# could be running an older version.
wd_cc_embed(
    name = "maximum-compatibility-date",
    src = ":trimmed-maximum-compatibility-date.txt",
    base_name = "maximum-compatibility-date",
)

wd_cc_embed(
    name = "wasm-instantiate-shim",
    src = "wasm-instantiate-shim.js",
    base_name = "wasm-instantiate-shim",
)

wd_capnp_library(src = "cdp.capnp")

wd_capnp_library(
    src = "worker-interface.capnp",
    deps = [
        ":frankenvalue_capnp",
        ":outcome_capnp",
        ":script-version_capnp",
        ":trace_capnp",
        "@capnp-cpp//src/capnp/compat:http-over-capnp_capnp",
    ],
)

wd_capnp_library(src = "actor-storage.capnp")

wd_capnp_library(src = "outcome.capnp")

wd_capnp_library(src = "script-version.capnp")

wd_capnp_library(src = "trace.capnp")

wd_capnp_library(src = "compatibility-date.capnp")

wd_capnp_library(src = "features.capnp")

wd_capnp_library(src = "frankenvalue.capnp")

wd_capnp_library(
    src = "container.capnp",
    deps = [
        ":compatibility-date_capnp",
        "@capnp-cpp//src/capnp/compat:byte-stream_capnp",
    ],
)

kj_test(
    src = "io-gate-test.c++",
    deps = [
        ":io-gate",
    ],
)

kj_test(
    src = "actor-cache-test.c++",
    deps = [
        ":actor",
        ":io-gate",
        "//src/workerd/util:test",
        "//src/workerd/util:test-util",
    ],
)

kj_test(
    src = "actor-sqlite-test.c++",
    deps = [
        ":actor",
        ":io-gate",
        "//src/workerd/util:test",
        "//src/workerd/util:test-util",
        "@sqlite3",
    ],
)

kj_test(
    src = "promise-wrapper-test.c++",
    # Omitting coverage because it takes a really long time executing it.
    tags = ["no-coverage"],
    deps = [
        ":io",
        ":promise-wrapper",
    ],
)

kj_test(
    src = "compatibility-date-test.c++",
    deps = [
        ":io",
        "@capnp-cpp//src/capnp:capnpc",
    ],
)

kj_test(
    src = "observer-test.c++",
    deps = [
        ":observer",
        "//src/workerd/io:worker-interface",
        "//src/workerd/util:strings",
        "@capnp-cpp//src/capnp:capnpc",
    ],
)

kj_test(
    src = "trace-test.c++",
    deps = [
        ":trace",
        "//src/workerd/util:thread-scopes",
    ],
)

kj_test(
    src = "frankenvalue-test.c++",
    deps = [
        ":frankenvalue",
    ],
)

kj_test(
    src = "worker-fs-test.c++",
    deps = [
        ":io",
    ],
)

wd_test(
    src = "io-context-test.wd-test",
    args = ["--experimental"],
    data = ["io-context-test.js"],
)

kj_test(
    src = "tracked-wasm-instance-test.c++",
    deps = [
        ":limit-enforcer",
    ],
)

wd_test(
    src = "tracked-wasm-instance-js-test.wd-test",
    args = ["--experimental"],
    data = [
        "tracked-wasm-instance-test.js",
        "//src/workerd/io/wasm:signal-basic.wasm",
        "//src/workerd/io/wasm:signal-bounds-check-edge.wasm",
        "//src/workerd/io/wasm:signal-bounds-check-overflow.wasm",
        "//src/workerd/io/wasm:signal-bounds-check-valid.wasm",
        "//src/workerd/io/wasm:signal-decoy-memory.wasm",
        "//src/workerd/io/wasm:signal-externref-memory.wasm",
        "//src/workerd/io/wasm:signal-imported-memory.wasm",
        "//src/workerd/io/wasm:signal-memory-reclaim.wasm",
        "//src/workerd/io/wasm:signal-no-globals.wasm",
        "//src/workerd/io/wasm:signal-partial-exports.wasm",
        "//src/workerd/io/wasm:signal-preinit.wasm",
        "//src/workerd/io/wasm:signal-terminated-only.wasm",
    ],
    # The WebAssembly.instantiate shim is behind the WASM_SHUTDOWN_SIGNAL_SHIM autogate,
    # so this test only works when all autogates are enabled.
    generate_all_compat_flags_variant = False,
    generate_default_variant = False,
)

kj_test(
    src = "bundle-fs-test.c++",
    deps = [
        ":bundle-fs",
        ":io",
        "//src/workerd/tests:test-fixture",
    ],
)

kj_test(
    src = "worker-getexportedhandler-test.c++",
    deps = [
        ":io",
        "//src/workerd/tests:test-fixture",
    ],
)