/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed 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.
 */
#pragma once
#include <filesystem>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>

struct irequest;

#include "oi/ContainerInfo.h"
#include "oi/Features.h"
#include "oi/FuncGen.h"
#include "oi/PaddingHunter.h"
#include "oi/TypeHierarchy.h"

extern "C" {
#include <drgn.h>
}

namespace oi::detail {
class SymbolService;
}

namespace oi::detail {

struct ParentMember {
  drgn_type* type;
  uint64_t bit_offset;

  bool operator<(const ParentMember& parent) const {
    return (bit_offset < parent.bit_offset);
  }
};

class OICodeGen {
 public:
  struct Config {
    Config() = default;
    Config(const Config& other) = delete;
    Config& operator=(const Config& other) = delete;
    Config(Config&& other) = delete;
    Config& operator=(Config&& other) = delete;

    struct KeyToCapture {
      std::optional<std::string> type;
      std::optional<std::string> member;
      bool topLevel = false;
    };

    FeatureSet features;
    std::set<std::filesystem::path> containerConfigPaths;
    std::set<std::string> defaultHeaders;
    std::set<std::string> defaultNamespaces;
    std::vector<std::pair<std::string, std::string>> membersToStub;
    std::vector<ContainerInfo> passThroughTypes;
    std::vector<KeyToCapture> keysToCapture;

    std::string toString() const;
    std::vector<std::string> toOptions() const;
  };

  // TODO: Should folly::Range just be added as a container?
  static constexpr auto typesToStub = std::array{
      "SharedMutex",
      "EnumMap",
      "function",
      "Function",
      "ConcurrentHashMap",
      "DelayedDestruction",
      "McServerSession",
      "Range",
      "ReadResumableHandle",
      "CountedIntrusiveList",
      "EventBaseAtomicNotificationQueue",
      /* Temporary IOBuf ring used for scattered read/write.
       * It's only used for communication and should be empty the rest of the
       * time. So we shouldn't loose too much visibility by stubbing it out.
       */
      "IOBufIovecBuilder",
      /* struct event from libevent
       * Its linked lists are not always initialised, leading to SegV in our JIT
       * code. We can't stub the linked list themselves, as they're anonymous
       * structs.
       */
      "event",
  };

 private:
  // Private constructor. Please use the fallible `OICodeGen::buildFromConfig`
  // for the expected behaviour.
  OICodeGen(const Config&, SymbolService&);

 public:
  static std::unique_ptr<OICodeGen> buildFromConfig(const Config&,
                                                    SymbolService&);
  bool generate(std::string& code);

  [[deprecated("Use generate(std::string&) instead.")]] bool
  generateFunctionsForTypesDrgn(std::string& code) {
    return generate(code);
  }

  bool registerContainer(const fs::path&);

  // TODO: remove me once all the callsites are gone
  static void initializeCodeGen();

  drgn_qualified_type getRootType();
  void setRootType(drgn_qualified_type rt);
  TypeHierarchy getTypeHierarchy();
  std::map<std::string, PaddingInfo> getPaddingInfo();

  bool isContainer(drgn_type* type);

  bool buildName(drgn_type* type, std::string& text, std::string& outName);

  std::string typeToTransformedName(drgn_type* type);

  bool enumerateTypesRecurse(drgn_type* type);
  static std::string_view drgnKindStr(drgn_type* type);
  std::set<drgn_type*> processedTypes;
  bool isDynamic(drgn_type* type) const;

 private:
  const Config& config;
  FuncGen funcGen;

  using ContainerTypeMapEntry =
      std::pair<std::reference_wrapper<const ContainerInfo>,
                std::vector<drgn_qualified_type>>;

  using TemplateParamList =
      std::vector<std::pair<drgn_qualified_type, std::string>>;

  using SortedTypeDefMap = std::vector<std::pair<drgn_type*, drgn_type*>>;

  std::string rootTypeStr;
  std::map<drgn_type*, std::string> unnamedUnion;
  std::map<std::string, size_t> sizeMap;
  std::map<drgn_type*, ContainerTypeMapEntry> containerTypeMapDrgn;
  std::vector<std::unique_ptr<ContainerInfo>> containerInfoList;
  std::vector<drgn_type*> enumTypes;
  std::vector<std::string> knownTypes;
  drgn_qualified_type rootType;
  drgn_qualified_type rootTypeToIntrospect;

  std::map<std::string, std::string> typedefMap;
  std::map<drgn_type*, std::vector<ParentMember>> parentClasses;
  std::map<std::string, std::vector<drgn_type*>> childClasses;
  std::map<drgn_type*, std::vector<drgn_type*>> descendantClasses;

  SymbolService& symbols;

  size_t pad_index = 0;
  std::unordered_map<drgn_type*, std::pair<size_t, size_t>> paddingIndexMap;

  std::map<drgn_type*, drgn_type*> typedefTypes;
  std::map<drgn_type*, std::vector<DrgnClassMemberInfo>> classMembersMap;
  std::map<drgn_type*, std::vector<DrgnClassMemberInfo>> classMembersMapCopy;
  std::map<drgn_type*, std::string> typeToNameMap;
  std::map<std::string, drgn_type*> nameToTypeMap;
  std::set<drgn_type*> funcDefTypeList;
  std::vector<drgn_type*> structDefType;
  std::set<drgn_type*> knownDummyTypeList;
  std::map<drgn_type*, drgn_type*> pointerToTypeMap;
  std::set<drgn_type*> thriftIssetStructTypes;
  std::vector<drgn_type*> topoSortedStructTypes;
  std::vector<std::pair<std::string, std::string>> membersToStub;

  ContainerInfoRefSet containerTypesFuncDef;

  std::map<std::string, PaddingInfo> paddedStructs;

  std::map<drgn_type*, std::vector<DrgnClassMemberInfo>>& getClassMembersMap();

  class DrgnString {
    struct FreeDeleter {
      void operator()(void* allocated) {
        free(allocated);
      }
    };

   public:
    std::string_view contents;
    DrgnString(char* data, size_t length)
        : contents{data, length}, _data{data} {
    }
    DrgnString() = delete;

   private:
    std::unique_ptr<char, FreeDeleter> _data;
  };

  bool feature(Feature f) const {
    return config.features[f];
  }
  static void prependQualifiers(enum drgn_qualifiers, std::string& sb);
  static std::string stripFullyQualifiedName(
      const std::string& fullyQualifiedName);
  std::string stripFullyQualifiedNameWithSeparators(
      const std::string& fullyQualifiedname);
  static void removeTemplateParamAtIndex(std::vector<std::string>& params,
                                         const size_t index);
  std::unordered_map<drgn_type*, DrgnString> fullyQualifiedNames;
  std::optional<const std::string_view> fullyQualifiedName(drgn_type* type);
  static SortedTypeDefMap getSortedTypeDefMap(
      const std::map<drgn_type*, drgn_type*>& typedefTypeMap);

  std::optional<std::reference_wrapper<const ContainerInfo>> getContainerInfo(
      drgn_type* type);
  void printAllTypes();
  void printAllTypeNames();

  static void addPaddingForBaseClass(drgn_type* type,
                                     std::vector<std::string>& def);
  void addTypeToName(drgn_type* type, std::string name);
  bool generateNamesForTypes();
  bool generateJitCode(std::string& code);
  bool generateStructDefs(std::string& code);
  bool generateStructDef(drgn_type* e, std::string& code);
  bool getDrgnTypeName(drgn_type* type, std::string& outName);

  bool getDrgnTypeNameInt(drgn_type* type, std::string& outName);
  bool recordChildren(drgn_type* type);
  bool enumerateChildClasses();
  bool populateDefsAndDecls();
  static void memberTransformName(
      std::map<std::string, std::string>& templateTransformMap,
      std::string& typeName);

  bool getMemberDefinition(drgn_type* type);
  bool isKnownType(const std::string& type);
  bool isKnownType(const std::string& type, std::string& matched);

  static bool getTemplateParams(
      drgn_type* type,
      size_t numTemplateParams,
      std::vector<std::pair<drgn_qualified_type, std::string>>& v);

  bool enumerateTemplateParamIdxs(drgn_type* type,
                                  const ContainerInfo& containerInfo,
                                  const std::vector<size_t>& paramIdxs,
                                  bool& ifStub);
  bool getContainerTemplateParams(drgn_type* type, bool& ifStub);
  void enumerateDescendants(drgn_type* type, drgn_type* baseType);
  void getFuncDefinitionStr(std::string& code,
                            drgn_type* type,
                            const std::string& typeName);
  std::optional<uint64_t> getDrgnTypeSize(drgn_type* type);

  std::optional<std::string> getNameForType(drgn_type* type);

  static std::string preProcessUniquePtr(drgn_type* type, std::string name);
  std::string transformTypeName(drgn_type* type, std::string& text);
  static std::string templateTransformType(const std::string& typeName);
  static std::string structNameTransformType(const std::string& typeName);

  bool addPadding(uint64_t padding_bits, std::string& code);
  static void deduplicateMemberName(
      std::unordered_map<std::string, int>& memberNames,
      std::string& memberName);
  std::optional<uint64_t> generateMember(
      const DrgnClassMemberInfo& m,
      std::unordered_map<std::string, int>& memberNames,
      uint64_t currOffsetBits,
      std::string& code,
      bool isInUnion);
  bool generateParent(drgn_type* p,
                      std::unordered_map<std::string, int>& memberNames,
                      uint64_t& currOffsetBits,
                      std::string& code,
                      size_t offsetToNextMember);
  std::optional<uint64_t> getAlignmentRequirements(drgn_type* e);
  bool generateStructMembers(drgn_type* e,
                             std::unordered_map<std::string, int>& memberNames,
                             std::string& code,
                             uint64_t& out_offset_bits,
                             PaddingInfo& paddingInfo,
                             bool& violatesAlignmentRequirement,
                             size_t offsetToNextMember);
  void getFuncDefClassMembers(std::string& code,
                              drgn_type* type,
                              std::unordered_map<std::string, int>& memberNames,
                              bool skipPadding = false);
  bool isDrgnSizeComplete(drgn_type* type);

  static bool getEnumUnderlyingTypeStr(drgn_type* e,
                                       std::string& enumUnderlyingTypeStr);

  bool ifEnumerateClass(const std::string& typeName);

  bool enumerateClassParents(drgn_type* type, const std::string& typeName);
  bool enumerateClassMembers(drgn_type* type,
                             const std::string& typeName,
                             bool& isStubbed);
  bool enumerateClassTemplateParams(drgn_type* type,
                                    const std::string& typeName,
                                    bool& isStubbed);
  bool ifGenerateMemberDefinition(const std::string& typeName);
  bool generateMemberDefinition(drgn_type* type, std::string& typeName);
  std::optional<std::pair<std::string_view, std::string_view>> isMemberToStub(
      const std::string& type, const std::string& member);
  std::optional<std::string_view> isTypeToStub(const std::string& typeName);
  bool isTypeToStub(drgn_type* type, const std::string& typeName);
  bool isEmptyClassOrFunctionType(drgn_type* type, const std::string& typeName);
  bool enumerateClassType(drgn_type* type);
  bool enumerateTypeDefType(drgn_type* type);
  bool enumerateEnumType(drgn_type* type);
  bool enumeratePointerType(drgn_type* type);
  bool enumeratePrimitiveType(drgn_type* type);
  bool enumerateArrayType(drgn_type* type);

  bool isUnnamedStruct(drgn_type* type);

  std::string getAnonName(drgn_type*, const char*);
  std::string getStructName(drgn_type* type) {
    return getAnonName(type, "__anon_struct_");
  }
  std::string getUnionName(drgn_type* type) {
    return getAnonName(type, "__anon_union_");
  }
  static void declareThriftStruct(std::string& code, std::string_view name);

  bool isNumMemberGreaterThanZero(drgn_type* type);
  void getClassMembersIncludingParent(drgn_type* type,
                                      std::vector<DrgnClassMemberInfo>& out);
  bool staticAssertMemberOffsets(
      const std::string& struct_name,
      drgn_type* struct_type,
      std::string& assert_str,
      std::unordered_map<std::string, int>& member_names,
      uint64_t base_offset = 0);
  bool addStaticAssertsForType(drgn_type* type,
                               bool generateAssertsForOffsets,
                               std::string& code);
  bool buildNameInt(drgn_type* type,
                    std::string& nameWithoutTemplate,
                    std::string& outName);
  void replaceTemplateOperator(
      std::vector<std::pair<drgn_qualified_type, std::string>>& template_params,
      std::vector<std::string>& template_params_strings,
      size_t index);
  void replaceTemplateParameters(
      drgn_type* type,
      std::vector<std::pair<drgn_qualified_type, std::string>>& template_params,
      std::vector<std::string>& template_params_strings,
      const std::string& nameWithoutTemplate);
};

}  // namespace oi::detail