#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::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

  // Do this after other creator->AddData() calls so that Snapshotable objects

  // can use 0 to indicate that a SnapshotIndex is invalid.

}

#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");

  }

  // 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().

  }

}

  // Bootstrap internal loaders

  Local<Value> loader_exports;

  }

  Local<Value> internal_binding_loader =

  Local<Value> require =

}

  }

    }

  }

  // 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.

  // This adjusts the return value of base_object_created_after_bootstrap() so

  // that tests that check the count do not have to account for internally

  // created BaseObjects.

}

  // When a process exits cleanly, i.e. because the event loop ends up without

  // things to wait for, the Node.js objects that are left on the heap should

  // be:

  //

  //   1. weak, i.e. ready for garbage collection once no longer referenced, or

  //   2. detached, i.e. scheduled for destruction once no longer referenced, or

  //   3. an unrefed libuv handle, i.e. does not keep the event loop alive, or

  //   4. an inactive libuv handle (essentially the same here)

  //

  // There are a few exceptions to this rule, but generally, if there are

  // C++-backed Node.js objects on the heap that do not fall into the above

  // categories, we may be looking at a potential memory leak. Most likely,

  // the cause is a missing MakeWeak() call on the corresponding object.

  //

  // In order to avoid this kind of problem, we check the list of BaseObjects

  // for these criteria. Currently, we only do so when explicitly instructed to

  // or when in debug mode (where --verify-base-objects is always-on).

  // TODO(legendecas): introduce per-realm options.

            "Found bad BaseObject during clean exit: %s\n",

  });

}

}  // namespace node