/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 **/

#ifndef QUICKSTEP_STORAGE_SUB_BLOCK_TYPE_REGISTRY_HPP_
#define QUICKSTEP_STORAGE_SUB_BLOCK_TYPE_REGISTRY_HPP_

#include <cstddef>
#include <type_traits>
#include <unordered_map>

#include "storage/StorageBlockLayout.pb.h"
#include "utility/Macros.hpp"

namespace quickstep {

class CatalogRelationSchema;

/** \addtogroup Expressions
 *  @{
 */

/**
 * @brief Singleton registry object that allows different implementations of
 *        TupleStorageSubBlock and IndexSubBlock to register their
 *        layout-verification and size-estimation functions for use by
 *        StorageBlockLayout.
 *
 * Some macros are provided to make using the SubBlockTypeRegistry easier. To
 * register an implementation of TupleStorageSubBlock, do the following:
 *     1. Include "storage/SubBlockTypeRegistry.hpp" in the implementation
 *        (.cpp) file, and put an invocation of the
 *        QUICKSTEP_REGISTER_TUPLE_STORE() macro in the quickstep namespace.
 *        For example:
 *        QUICKSTEP_REGISTER_TUPLE_STORE(SplitRowStoreTupleStorageSubBlock, SPLIT_ROW_STORE);
 *        The first argument to the macro is the name of the class, the second
 *        is the name of the class' corresponding case in the
 *        TupleStorageSubBlockDescription::TupleStorageSubBlockType enum.
 *     2. Include "storage/SubBlockTypeRegistryMacros.hpp" in the header (.hpp)
 *        file, and put an invocation of the
 *        QUICKSTEP_DECLARE_SUB_BLOCK_TYPE_REGISTERED() macro in the quickstep
 *        namespace like so:
 *        QUICKSTEP_DECLARE_SUB_BLOCK_TYPE_REGISTERED(SplitRowStoreTupleStorageSubBlock);
 *
 * Registration of IndexSubBlock implementations works the same way, except the
 * first macro used should be QUICKSTEP_REGISTER_INDEX() instead of
 * QUICKSTEP_REGISTER_TUPLE_STORE().
 *
 * SubBlockTypeRegistryMacros.hpp additionally provides a macro
 * QUICKSTEP_FORCE_SUB_BLOCK_REGISTRATION(block_type) that can be used by
 * executable targets to force linking and registration of particular SubBlock
 * types in executables that never actually instantiate the block types in
 * question. This is mainly useful for tests that need to verify the
 * correctness of a StorageBlockLayout, but never actually create any
 * StorageBlocks. See Catalog_unittest for an example.
 **/
class SubBlockTypeRegistry {
 private:
  typedef typename std::underlying_type<TupleStorageSubBlockDescription::TupleStorageSubBlockType>::type
      TupleStoreTypeIntegral;

  typedef typename std::underlying_type<IndexSubBlockDescription::IndexSubBlockType>::type
      IndexTypeIntegral;

 public:
  typedef bool (*TupleStoreDescriptionIsValidFunction)(
      const CatalogRelationSchema&,
      const TupleStorageSubBlockDescription&);

  typedef std::size_t (*TupleStoreEstimateBytesPerTupleFunction)(
      const CatalogRelationSchema&,
      const TupleStorageSubBlockDescription&);

  typedef bool (*IndexDescriptionIsValidFunction)(
      const CatalogRelationSchema&,
      const IndexSubBlockDescription&);

  typedef std::size_t (*IndexEstimateBytesPerTupleFunction)(
      const CatalogRelationSchema&,
      const IndexSubBlockDescription&);

  typedef std::size_t (*IndexEstimateBytesPerBlockFunction)(
      const CatalogRelationSchema&,
      const IndexSubBlockDescription&);

  static bool RegisterTupleStoreDescriptionIsValidFunction(
      const TupleStorageSubBlockDescription::TupleStorageSubBlockType sub_block_type,
      TupleStoreDescriptionIsValidFunction function) {
    Instance()->tuple_store_description_is_valid_functions_[
        static_cast<TupleStoreTypeIntegral>(sub_block_type)] = function;
    return true;
  }

  static bool RegisterTupleStoreEstimateBytesPerTupleFunction(
      const TupleStorageSubBlockDescription::TupleStorageSubBlockType sub_block_type,
      TupleStoreEstimateBytesPerTupleFunction function) {
    Instance()->tuple_store_estimate_bytes_per_tuple_functions_[
        static_cast<TupleStoreTypeIntegral>(sub_block_type)] = function;
    return true;
  }

  static bool RegisterIndexDescriptionIsValidFunction(
      const IndexSubBlockDescription::IndexSubBlockType sub_block_type,
      IndexDescriptionIsValidFunction function) {
    Instance()->index_description_is_valid_functions_[
        static_cast<IndexTypeIntegral>(sub_block_type)] = function;
    return true;
  }

  static bool RegisterIndexEstimateBytesPerTupleFunction(
      const IndexSubBlockDescription::IndexSubBlockType sub_block_type,
      IndexEstimateBytesPerTupleFunction function) {
    Instance()->index_estimate_bytes_per_tuple_functions_[
        static_cast<IndexTypeIntegral>(sub_block_type)] = function;
    return true;
  }

  static bool RegisterIndexEstimateBytesPerBlockFunction(
      const IndexSubBlockDescription::IndexSubBlockType sub_block_type,
      IndexEstimateBytesPerBlockFunction function) {
    Instance()->index_estimate_bytes_per_block_functions_[
      static_cast<IndexTypeIntegral>(sub_block_type)] = function;
    return true;
  }

  static bool LayoutDescriptionIsValid(
      const CatalogRelationSchema &relation,
      const StorageBlockLayoutDescription &description);

  static bool IndexDescriptionIsValid(
      const CatalogRelationSchema &relation,
      const IndexSubBlockDescription &description);

  static std::size_t EstimateBytesPerTupleForTupleStore(
      const CatalogRelationSchema &relation,
      const TupleStorageSubBlockDescription &description);

  static std::size_t EstimateBytesPerTupleForIndex(
      const CatalogRelationSchema &relation,
      const IndexSubBlockDescription &description);

  static std::size_t EstimateBytesPerBlockForIndex(
      const CatalogRelationSchema &relation,
      const IndexSubBlockDescription &description);

 private:
  std::unordered_map<TupleStoreTypeIntegral,
                     TupleStoreDescriptionIsValidFunction>
      tuple_store_description_is_valid_functions_;

  std::unordered_map<TupleStoreTypeIntegral,
                     TupleStoreEstimateBytesPerTupleFunction>
      tuple_store_estimate_bytes_per_tuple_functions_;

  std::unordered_map<IndexTypeIntegral,
                     IndexDescriptionIsValidFunction>
      index_description_is_valid_functions_;

  std::unordered_map<IndexTypeIntegral,
                     IndexEstimateBytesPerTupleFunction>
      index_estimate_bytes_per_tuple_functions_;

  std::unordered_map<IndexTypeIntegral,
                     IndexEstimateBytesPerTupleFunction>
      index_estimate_bytes_per_block_functions_;

  SubBlockTypeRegistry() {
  }

  static SubBlockTypeRegistry* Instance() {
    static SubBlockTypeRegistry instance;
    return &instance;
  }

  DISALLOW_COPY_AND_ASSIGN(SubBlockTypeRegistry);
};

/** @} */

}  // namespace quickstep

#define QUICKSTEP_REGISTER_TUPLE_STORE(classname, proto_enum_case)                         \
namespace registry {                                                                       \
  static const bool classname##_desc_registered                                            \
      = quickstep::SubBlockTypeRegistry::RegisterTupleStoreDescriptionIsValidFunction(     \
          TupleStorageSubBlockDescription::proto_enum_case,                                \
          &classname::DescriptionIsValid);                                                 \
  static const bool classname##_size_registered                                            \
      = quickstep::SubBlockTypeRegistry::RegisterTupleStoreEstimateBytesPerTupleFunction(  \
          TupleStorageSubBlockDescription::proto_enum_case,                                \
          &classname::EstimateBytesPerTuple);                                              \
  const bool classname##_registered                                                        \
      = classname##_desc_registered && classname##_size_registered;                        \
  bool classname##_check_registered() { return classname##_registered; }                   \
}  /* namespace registry */                                                                \
using registry::classname##_registered

#define QUICKSTEP_REGISTER_INDEX(classname, proto_enum_case)                          \
namespace registry {                                                                  \
  static const bool classname##_desc_registered                                       \
      = quickstep::SubBlockTypeRegistry::RegisterIndexDescriptionIsValidFunction(     \
          IndexSubBlockDescription::proto_enum_case,                                  \
          &classname::DescriptionIsValid);                                            \
  static const bool classname##_size_per_tuple_registered                             \
      = quickstep::SubBlockTypeRegistry::RegisterIndexEstimateBytesPerTupleFunction(  \
          IndexSubBlockDescription::proto_enum_case,                                  \
          &classname::EstimateBytesPerTuple);                                         \
  static const bool classname##_size_per_block_registered                             \
      = quickstep::SubBlockTypeRegistry::RegisterIndexEstimateBytesPerBlockFunction(  \
          IndexSubBlockDescription::proto_enum_case,                                  \
          &classname::EstimateBytesPerBlock);                                         \
  const bool classname##_registered                                                   \
      = classname##_desc_registered && classname##_size_per_tuple_registered          \
          && classname##_size_per_block_registered;                                   \
  bool classname##_check_registered() { return classname##_registered; }              \
}  /* namespace registry */                                                           \
using registry::classname##_registered

#endif  // QUICKSTEP_STORAGE_SUB_BLOCK_TYPE_REGISTRY_HPP_