#ifndef SRC_CRYPTO_CRYPTO_KEYGEN_H_

#define SRC_CRYPTO_CRYPTO_KEYGEN_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "async_wrap.h"

#include "base_object.h"

#include "crypto/crypto_keys.h"

#include "crypto/crypto_util.h"

#include "env.h"

#include "memory_tracker.h"

#include "v8.h"

namespace node {

namespace crypto {

namespace Keygen {

void Initialize(Environment* env, v8::Local<v8::Object> target);

void RegisterExternalReferences(ExternalReferenceRegistry* registry);

}  // namespace Keygen

enum class KeyGenJobStatus {

  OK,

  FAILED

};

// A Base CryptoJob for generating secret keys or key pairs.

// The KeyGenTraits is largely responsible for the details of

// the implementation, while KeyGenJob handles the common

// mechanisms.

template <typename KeyGenTraits>

class KeyGenJob final : public CryptoJob<KeyGenTraits> {

 public:

  using AdditionalParams = typename KeyGenTraits::AdditionalParameters;

            .IsNothing()) {

      // The KeyGenTraits::AdditionalConfig is responsible for

      // calling an appropriate THROW_CRYPTO_* variant reporting

      // whatever error caused initialization to fail.

    }

  }

      Environment* env,

      v8::Local<v8::Object> target) {

      Environment* env,

      v8::Local<v8::Object> object,

      CryptoJobMode mode,

      AdditionalParams&& params)

      : CryptoJob<KeyGenTraits>(

            env,

            object,

            KeyGenTraits::Provider,

            mode,

    // Make sure the CSPRNG is properly seeded so the results are secure.

        // Success!

      }

    }

      v8::Local<v8::Value>* err,

      v8::Local<v8::Value>* result) override {

      }

    }

  }

 private:

  KeyGenJobStatus status_ = KeyGenJobStatus::FAILED;

};

// A Base KeyGenTraits for Key Pair generation algorithms.

template <typename KeyPairAlgorithmTraits>

struct KeyPairGenTraits final {

  using AdditionalParameters =

      typename KeyPairAlgorithmTraits::AdditionalParameters;

  static const AsyncWrap::ProviderType Provider =

      AsyncWrap::PROVIDER_KEYPAIRGENREQUEST;

  static constexpr const char* JobName = KeyPairAlgorithmTraits::JobName;

      CryptoJobMode mode,

      const v8::FunctionCallbackInfo<v8::Value>& args,

      unsigned int* offset,

      AdditionalParameters* params) {

    // Notice that offset is a pointer. Each of the AdditionalConfig,

    // GetPublicKeyEncodingFromJs, and GetPrivateKeyEncodingFromJs

    // functions will update the value of the offset as they successfully

    // process input parameters. This allows each job to have a variable

    // number of input parameters specific to each job type.

            .IsNothing()) {

    }

        args,

        offset,

        kKeyContextGenerate);

        ManagedEVPPKey::GetPrivateKeyEncodingFromJs(

            args,

            offset,

            kKeyContextGenerate);

  }

      Environment* env,

      AdditionalParameters* params) {

    // Generate the key

  }

      Environment* env,

      AdditionalParameters* params,

      v8::Local<v8::Value>* result) {

            env,

            env,

            &keys[1]).IsNothing()) {

    }

  }

};

struct SecretKeyGenConfig final : public MemoryRetainer {

  size_t length;  // Expressed a a number of bits

  char* out = nullptr;  // Placeholder for the generated key bytes

  void MemoryInfo(MemoryTracker* tracker) const override;

};

struct SecretKeyGenTraits final {

  using AdditionalParameters = SecretKeyGenConfig;

  static const AsyncWrap::ProviderType Provider =

      AsyncWrap::PROVIDER_KEYGENREQUEST;

  static constexpr const char* JobName = "SecretKeyGenJob";

  static v8::Maybe<bool> AdditionalConfig(

      CryptoJobMode mode,

      const v8::FunctionCallbackInfo<v8::Value>& args,

      unsigned int* offset,

      SecretKeyGenConfig* params);

  static KeyGenJobStatus DoKeyGen(

      Environment* env,

      SecretKeyGenConfig* params);

  static v8::Maybe<bool> EncodeKey(

      Environment* env,

      SecretKeyGenConfig* params,

      v8::Local<v8::Value>* result);

};

template <typename AlgorithmParams>

struct KeyPairGenConfig final : public MemoryRetainer {

  PublicKeyEncodingConfig public_key_encoding;

  PrivateKeyEncodingConfig private_key_encoding;

  ManagedEVPPKey key;

  AlgorithmParams params;

  }

      : public_key_encoding(other.public_key_encoding),

        private_key_encoding(

            std::forward<PrivateKeyEncodingConfig>(

  KeyPairGenConfig& operator=(KeyPairGenConfig&& other) noexcept {

    if (&other == this) return *this;

    this->~KeyPairGenConfig();

    return *new (this) KeyPairGenConfig(std::move(other));

  }

                                  private_key_encoding.passphrase_->size());

    }

  }

};

struct NidKeyPairParams final : public MemoryRetainer {

  int id;

};

using NidKeyPairGenConfig = KeyPairGenConfig<NidKeyPairParams>;

struct NidKeyPairGenTraits final {

  using AdditionalParameters = NidKeyPairGenConfig;

  static constexpr const char* JobName = "NidKeyPairGenJob";

  static EVPKeyCtxPointer Setup(NidKeyPairGenConfig* params);

  static v8::Maybe<bool> AdditionalConfig(

      CryptoJobMode mode,

      const v8::FunctionCallbackInfo<v8::Value>& args,

      unsigned int* offset,

      NidKeyPairGenConfig* params);

};

using NidKeyPairGenJob = KeyGenJob<KeyPairGenTraits<NidKeyPairGenTraits>>;

using SecretKeyGenJob = KeyGenJob<SecretKeyGenTraits>;

}  // namespace crypto

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_CRYPTO_CRYPTO_KEYGEN_H_