#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2021 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

// If the library is compiled as a DLL, this ensures symbols are exported
#define NUCLEX_STORAGE_SOURCE 1

#include "Nuclex/Storage/MemoryBlob.h"

#include <algorithm> // for std::copy_n()
#include <limits> // for std::numeric_limits
#include <stdexcept> // for std::out_of_range
#include <cassert> // for assert()

namespace {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Grows the vector to at least the specified capacity</summary>
  /// <param name="vector">Vector that will be grown</param>
  /// <param name="requiredCapacity">Minimum capacity the vector will be grown to</param>
  /// <remarks>
  ///   <para>
  ///     The <code>std::vector&lt;T&gt;::reserve()</code> method is free to do this itself,
  ///     but most implementations grow to the exact size, probably in the assumption that if
  ///     the developer goes through the effort of calling reserve(), he knows exactly
  ///     how much memory will be required (I'm not complaining).
  ///   </para>
  ///   <para>
  ///     This behavior could wreak havoc on performance if a binary blob writer was to
  ///     append small chunks of data (eg. 4 byte integers) to an already large blob.
  ///     Thus we ensure the reserve() behavior matches the scheme employed by push_back()
  ///     in most implementations of <code>std::vector&lt;T&gt;</code>.
  ///   </para>
  /// </remarks>
  template<typename T>
  void growVector(std::vector<T> &vector, std::size_t requiredCapacity) {
    std::size_t capacity = vector.capacity();
    if(capacity < requiredCapacity) {
      capacity += capacity / 2;
      if(capacity < requiredCapacity) {
        capacity = requiredCapacity;
      }

      vector.reserve(capacity);
    }
  }

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Scoped unlocker for a shared lock on a mutex</summary>
  class SharedMutexLockScope {

    /// <summary>Initializes the mutex unlocking scope on the specified mutex</summary>
    public: SharedMutexLockScope(std::shared_mutex &mutex) :
      mutex(mutex) {}

    /// <summary>Releases the shared lock on the scope's mutex</summary>
    public: ~SharedMutexLockScope() {
      this->mutex.unlock_shared();
    }

    /// <summary>Mutex that will be unlocked when the scope is destroyed</summary>
    private: std::shared_mutex &mutex;

  };

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Scoped unlocker for an exclusive lock on a mutex</summary>
  class ExclusiveMutexLockScope {

    /// <summary>Initializes the mutex unlocking scope on the specified mutex</summary>
    public: ExclusiveMutexLockScope(std::shared_mutex &mutex) :
      mutex(mutex) {}

    /// <summary>Releases the exclusive lock on the scope's mutex</summary>
    public: ~ExclusiveMutexLockScope() {
      this->mutex.unlock();
    }

    /// <summary>Mutex that will be unlocked when the scope is destroyed</summary>
    private: std::shared_mutex &mutex;

  };

  // ------------------------------------------------------------------------------------------- //

} // anonymous namespace

namespace Nuclex { namespace Storage {

  // ------------------------------------------------------------------------------------------- //

  void MemoryBlob::ReadAt(std::uint64_t location, void *buffer, std::size_t count) const {
    assert(
      (location < std::numeric_limits<std::size_t>::max()) &&
      u8"Read location must be within range of the platform's std::size_t type"
    );
    assert(
      ((location + count) < std::numeric_limits<std::size_t>::max()) &&
      u8"Read must be end within range of the platform's std::size_t type"
    );

    this->mutex.lock_shared();
    {
      SharedMutexLockScope sharedMutexUnlocker(this->mutex);

      std::copy_n(
        &this->memory.at(static_cast<std::size_t>(location)),
        count,
        static_cast<unsigned char *>(buffer)
      );
    }
  }

  // ------------------------------------------------------------------------------------------- //

  void MemoryBlob::WriteAt(std::uint64_t location, const void *buffer, std::size_t count) {
    assert(
      (location < std::numeric_limits<std::size_t>::max()) &&
      u8"Write location must be within range of the platform's std::size_t type"
    );
    assert(
      ((location + count) < std::numeric_limits<std::size_t>::max()) &&
      u8"Write must be end within range of the platform's std::size_t type"
    );

    std::size_t start = static_cast<std::size_t>(location);
    std::size_t end = start + count;

    this->mutex.lock_shared();

    // Look up the size of the vector. We assume that this will not throw.
    std::size_t blobSize = this->memory.size();
    if(unlikely(start > blobSize)) {
      throw std::out_of_range(
        u8"Attempted write past the end of the memory blob (would create undefined gap)"
      );
    }

    // If the data to be written fits within the vector's size, just write
    // (synchronizing reads and writes is the caller's task, we're just making
    // sure that we don't segfault and never return undefined data)
    if(likely(end < blobSize)) {
      SharedMutexLockScope sharedMutexUnlocker(this->mutex);
      std::copy_n(
        static_cast<const std::uint8_t *>(buffer),
        count,
        this->memory.data() + static_cast<std::size_t>(location)
      );
    } else { // Resize needed, shared mutex lock is not enough!
      this->mutex.unlock_shared();
      this->mutex.lock();
      {
        ExclusiveMutexLockScope exclusiveMutexUnlocker(this->mutex);

        growVector(this->memory, end);

        // Copy those bytes that overwrite existing data in the vector directly
        std::size_t overwriteCount = std::min(blobSize, end) - start;
        if(overwriteCount > 0) {
          std::copy_n(
            static_cast<const uint8_t *>(buffer),
            overwriteCount,
            this->memory.data() + static_cast<std::size_t>(location)
          );
        }

        // Append those bytes that grow the buffer using the insert() method
        if(count > overwriteCount) {
          this->memory.insert(
            this->memory.end(),
            static_cast<const std::uint8_t *>(buffer) + overwriteCount,
            static_cast<const std::uint8_t *>(buffer) + count
          );
        }
      } // exclusive mutex lock
    }
  }

  // ------------------------------------------------------------------------------------------- //

}} // namespace Nuclex::Storage