#ifndef SRC_ALIASED_BUFFER_H_

#define SRC_ALIASED_BUFFER_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include <cinttypes>

#include <iostream>

#include "util-inl.h"

#include "v8.h"

namespace node {

typedef size_t AliasedBufferIndex;

/**

 * Do not use this class directly when creating instances of it - use the

 * Aliased*Array defined at the end of this file instead.

 *

 * This class encapsulates the technique of having a native buffer mapped to

 * a JS object. Writes to the native buffer can happen efficiently without

 * going through JS, and the data is then available to user's via the exposed

 * JS object.

 *

 * While this technique is computationally efficient, it is effectively a

 * write to JS program state w/out going through the standard

 * (monitored) API. Thus any VM capabilities to detect the modification are

 * circumvented.

 *

 * The encapsulation herein provides a placeholder where such writes can be

 * observed. Any notification APIs will be left as a future exercise.

 */

template <class NativeT,

          class V8T,

          // SFINAE NativeT to be scalar

          typename = std::enable_if_t<std::is_scalar<NativeT>::value>>

 public:

                    const size_t count,

                    const AliasedBufferIndex* index = nullptr)

      // Will be deserialized later.

    }

    const size_t size_in_bytes =

    // allocate v8 ArrayBuffer

    // allocate v8 TypedArray

  }

  /**

   * Create an AliasedBufferBase over a sub-region of another aliased buffer.

   * The two will share a v8::ArrayBuffer instance &

   * a native buffer, but will each read/write to different sections of the

   * native buffer.

   *

   *  Note that byte_offset must by aligned by sizeof(NativeT).

   */

  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`

      v8::Isolate* isolate,

      const size_t byte_offset,

      const size_t count,

      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,

      const AliasedBufferIndex* index = nullptr)

      : isolate_(isolate),

        count_(count),

        byte_offset_(byte_offset),

      // Will be deserialized later.

    }

    // validate that the byte_offset is aligned with sizeof(NativeT)

    // validate this fits inside the backing buffer

             ab->ByteLength() - byte_offset);

  }

    DCHECK_NULL(index_);

                              v8::SnapshotCreator* creator) {

    DCHECK_NULL(index_);

  }

    DCHECK_NOT_NULL(index_);

    v8::Local<V8T> arr =

    // These may not hold true for AliasedBuffers that have grown, so should

    // be removed when we expand the snapshot support.

    DCHECK_EQ(count_, arr->Length());

    DCHECK_EQ(byte_offset_, arr->ByteOffset());

    uint8_t* raw =

  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {

    DCHECK_NULL(index_);

    this->~AliasedBufferBase();

    isolate_ = that.isolate_;

    count_ = that.count_;

    byte_offset_ = that.byte_offset_;

    buffer_ = that.buffer_;

    js_array_.Reset(isolate_, that.js_array_.Get(isolate_));

    that.buffer_ = nullptr;

    that.js_array_.Reset();

    return *this;

  }

  /**

   * Helper class that is returned from operator[] to support assignment into

   * a specified location.

   */

  class Reference {

   public:

    }

    }

    }

    }

    }

    }

   private:

    AliasedBufferBase<NativeT, V8T>* aliased_buffer_;

    size_t index_;

  };

  /**

   *  Get the underlying v8 TypedArray overlayed on top of the native buffer

   */

    DCHECK_NULL(index_);

  }

  /**

  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and

  *  overlaying the native buffer

  */

  }

  /**

   *  Get the underlying native buffer. Note that all reads/writes should occur

   *  through the GetValue/SetValue/operator[] methods

   */

    DCHECK_NULL(index_);

  }

  /**

   *  Synonym for GetBuffer()

   */

  }

  /**

   *  Set position index to given value.

   */

    DCHECK_LT(index, count_);

    DCHECK_NULL(index_);

  /**

   *  Get value at position index

   */

    DCHECK_NULL(index_);

    DCHECK_LT(index, count_);

  }

  /**

   *  Effectively, a synonym for GetValue/SetValue

   */

    DCHECK_NULL(index_);

  }

  }

  }

  // Should only be used to extend the array.

  // Should only be used on an owning array, not one created as a sub array of

  // an owning `AliasedBufferBase`.

    DCHECK_NULL(index_);

    DCHECK_GE(new_capacity, count_);

    DCHECK_EQ(byte_offset_, 0);

    const size_t new_size_in_bytes = MultiplyWithOverflowCheck(sizeof(NativeT),

    // allocate v8 new ArrayBuffer

    // allocate new native buffer

    // copy old content

    // allocate v8 TypedArray

    // move over old v8 TypedArray

 private:

  v8::Isolate* isolate_ = nullptr;

  size_t count_ = 0;

  size_t byte_offset_ = 0;

  NativeT* buffer_ = nullptr;

  v8::Global<V8T> js_array_;

  // Deserialize data

  const AliasedBufferIndex* index_ = nullptr;

};

typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;

typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;

typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;

typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;

typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_ALIASED_BUFFER_H_