#include "node_realm.h"

#include "env-inl.h"

#include "memory_tracker-inl.h"

#include "node_builtins.h"

#include "node_process.h"

#include "util.h"

namespace node {

using builtins::BuiltinLoader;

using v8::Context;

using v8::EscapableHandleScope;

using v8::Function;

using v8::HandleScope;

using v8::Local;

using v8::MaybeLocal;

using v8::Object;

using v8::SnapshotCreator;

using v8::String;

using v8::Undefined;

using v8::Value;

             v8::Local<v8::Context> context,

  // Create properties if not deserializing from snapshot.

  // Or the properties are deserialized with DeserializeProperties() when the

  // env drained the deserialize requests.

  }

#define V(PropertyName, TypeName)                                              \

  tracker->TrackField(#PropertyName, PropertyName());

#undef V

  // Store primordials setup by the per-context script in the environment.

  Local<Object> per_context_bindings =

  Local<Value> primordials =

  Local<String> prototype_string =

#define V(EnvPropertyName, PrimordialsPropertyName)                            \

  {                                                                            \

    Local<Value> ctor =                                                        \

        primordials.As<Object>()                                               \

            ->Get(ctx,                                                         \

                  FIXED_ONE_BYTE_STRING(isolate(), PrimordialsPropertyName))   \

            .ToLocalChecked();                                                 \

    CHECK(ctor->IsObject());                                                   \

    Local<Value> prototype =                                                   \

        ctor.As<Object>()->Get(ctx, prototype_string).ToLocalChecked();        \

    CHECK(prototype->IsObject());                                              \

    set_##EnvPropertyName(prototype.As<Object>());                             \

  }

#undef V

  // TODO(legendecas): some methods probably doesn't need to be created with

  // process. Distinguish them and create process object only in the principal

  // realm.

  Local<Object> process_object =

#define V(PropertyName, TypeName)                                              \

  do {                                                                         \

    Local<TypeName> field = PropertyName();                                    \

    if (!field.IsEmpty()) {                                                    \

      size_t index = creator->AddData(ctx, field);                             \

      info.persistent_values.push_back({#PropertyName, id, index});            \

    }                                                                          \

    id++;                                                                      \

  } while (0);

#undef V

}

#define V(PropertyName, TypeName)                                              \

  do {                                                                         \

    if (values.size() > i && id == values[i].id) {                             \

      const PropInfo& d = values[i];                                           \

      DCHECK_EQ(d.name, #PropertyName);                                        \

      MaybeLocal<TypeName> maybe_field =                                       \

          ctx->GetDataFromSnapshotOnce<TypeName>(d.index);                     \

      Local<TypeName> field;                                                   \

      if (!maybe_field.ToLocal(&field)) {                                      \

        fprintf(stderr,                                                        \

                "Failed to deserialize realm value " #PropertyName "\n");      \

      }                                                                        \

      set_##PropertyName(field);                                               \

      i++;                                                                     \

    }                                                                          \

    id++;                                                                      \

  } while (0);

#undef V

  MaybeLocal<Context> maybe_ctx_from_snapshot =

  Local<Context> ctx_from_snapshot;

            "Failed to deserialize context back reference from the snapshot\n");

  }

    const char* id, std::vector<Local<Value>>* arguments) {

  MaybeLocal<Function> maybe_fn =

  Local<Function> fn;

  }

  MaybeLocal<Value> result =

  // If there was an error during bootstrap, it must be unrecoverable

  // (e.g. max call stack exceeded). Clear the stack so that the

  // AsyncCallbackScope destructor doesn't fail on the id check.

  // There are only two ways to have a stack size > 1: 1) the user manually

  // called MakeCallback or 2) user awaited during bootstrap, which triggered

  // _tickCallback().

  }

}

  // Arguments must match the parameters specified in

  // BuiltinLoader::LookupAndCompile().

  std::vector<Local<Value>> loaders_args = {

      process_object(),

          .ToLocalChecked(),

          .ToLocalChecked(),

  // Bootstrap internal loaders

  Local<Value> loader_exports;

  }

  Local<Value> internal_binding_loader =

  Local<Value> require =

}

  // Arguments must match the parameters specified in

  // BuiltinLoader::LookupAndCompile().

  // process, require, internalBinding, primordials

  std::vector<Local<Value>> node_args = {process_object(),

                                         builtin_module_require(),

                                         internal_binding_loader(),

  MaybeLocal<Value> result =

  }

    }

  }

  // TODO(joyeecheung): skip these in the snapshot building for workers.

  auto thread_switch_id =

  }

  auto process_state_switch_id =

  }

  Local<Object> env_var_proxy;

  }

}

  }

  Local<Value> result;

  }

}

  // Make sure that no request or handle is created during bootstrap -

  // if necessary those should be done in pre-execution.

  // Usually, doing so would trigger the checks present in the ReqWrap and

  // HandleWrap classes, so this is only a consistency check.

  // TODO(legendecas): track req_wrap and handle_wrap by realms instead of

  // environments.

  // TODO(legendecas): track base object count by realms.

}  // namespace node