// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_
#define ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_

#include <fidl/flat_ast.h>
#include <fidl/json_generator.h>
#include <fidl/lexer.h>
#include <fidl/linter.h>
#include <fidl/ordinals.h>
#include <fidl/parser.h>
#include <fidl/source_file.h>
#include <fidl/tables_generator.h>

static std::unique_ptr<fidl::SourceFile> MakeSourceFile(const std::string& filename,
                                                        const std::string& raw_source_code) {
  std::string source_code(raw_source_code);
  // NUL terminate the string.
  source_code.resize(source_code.size() + 1);
  return std::make_unique<fidl::SourceFile>(filename, source_code);
}

class SharedAmongstLibraries {
 public:
  SharedAmongstLibraries() : typespace(fidl::flat::Typespace::RootTypes(&reporter)) {}

  fidl::Reporter reporter;
  fidl::flat::Typespace typespace;
  fidl::flat::Libraries all_libraries;
  std::vector<std::unique_ptr<fidl::SourceFile>> all_sources_of_all_libraries;
};

namespace {

// See ordinals_test.cc
fidl::raw::Ordinal64 GetGeneratedOrdinal64ForTesting(
    const std::vector<std::string_view>& library_name, const std::string_view& protocol_name,
    const std::string_view& selector_name, const fidl::raw::SourceElement& source_element) {
  static std::map<std::string, uint64_t> special_selectors = {
      {"ThisOneHashesToZero", 0},
      {"ClashOne", 456789},
      {"ClashOneReplacement", 987654},
      {"ClashTwo", 456789},
  };
  if (library_name.size() == 1 && library_name[0] == "methodhasher" &&
      (protocol_name == "Special" || protocol_name == "SpecialComposed")) {
    auto it = special_selectors.find(std::string(selector_name));
    assert(it != special_selectors.end() && "only special selectors allowed");
    return fidl::raw::Ordinal64(source_element, it->second);
  }
  return fidl::ordinals::GetGeneratedOrdinal64(library_name, protocol_name, selector_name,
                                               source_element);
}
};  // namespace

class TestLibrary final {
 public:
  explicit TestLibrary() : TestLibrary(&owned_shared_) {}

  explicit TestLibrary(SharedAmongstLibraries* shared,
                       fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
      : reporter_(&shared->reporter),
        experimental_flags_(experimental_flags),
        typespace_(&shared->typespace),
        all_libraries_(&shared->all_libraries),
        all_sources_of_all_libraries_(&shared->all_sources_of_all_libraries),
        library_(std::make_unique<fidl::flat::Library>(all_libraries_, reporter_, typespace_,
                                                       GetGeneratedOrdinal64ForTesting,
                                                       experimental_flags_)) {}

  explicit TestLibrary(const std::string& raw_source_code,
                       fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
      : TestLibrary("example.fidl", raw_source_code, experimental_flags) {}

  TestLibrary(const std::string& filename, const std::string& raw_source_code,
              fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
      : TestLibrary(filename, raw_source_code, &owned_shared_, experimental_flags) {}

  TestLibrary(const std::string& filename, const std::string& raw_source_code,
              SharedAmongstLibraries* shared,
              fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
      : TestLibrary(shared, experimental_flags) {
    AddSource(filename, raw_source_code);
  }

  void AddSource(const std::string& filename, const std::string& raw_source_code) {
    auto source_file = MakeSourceFile(filename, raw_source_code);
    all_sources_.push_back(source_file.get());
    all_sources_of_all_libraries_->push_back(std::move(source_file));
  }

  bool AddDependentLibrary(TestLibrary dependent_library) {
    return all_libraries_->Insert(std::move(dependent_library.library_));
  }

  void AddAttributeSchema(const std::string& name, fidl::flat::AttributeSchema schema) {
    all_libraries_->AddAttributeSchema(name, std::move(schema));
  }

  // TODO(pascallouis): remove, this does not use a library.
  bool Parse(std::unique_ptr<fidl::raw::File>* out_ast_ptr) {
    assert(all_sources_.size() == 1 && "parse can only be used with one source");
    auto source_file = all_sources_.at(0);
    fidl::Lexer lexer(*source_file, reporter_);
    fidl::Parser parser(&lexer, reporter_, experimental_flags_);
    out_ast_ptr->reset(parser.Parse().release());
    return parser.Success();
  }

  bool Compile() {
    for (auto source_file : all_sources_) {
      fidl::Lexer lexer(*source_file, reporter_);
      fidl::Parser parser(&lexer, reporter_, experimental_flags_);
      auto ast = parser.Parse();
      if (!parser.Success())
        return false;
      if (!library_->ConsumeFile(std::move(ast)))
        return false;
    }
    return library_->Compile();
  }

  // TODO(pascallouis): remove, this does not use a library.
  bool Lint(fidl::Findings* findings, const std::set<std::string>& included_check_ids = {},
            const std::set<std::string>& excluded_check_ids = {}, bool exclude_by_default = false,
            std::set<std::string>* excluded_checks_not_found = nullptr) {
    assert(all_sources_.size() == 1 && "lint can only be used with one source");
    auto source_file = all_sources_.at(0);
    fidl::Lexer lexer(*source_file, reporter_);
    fidl::Parser parser(&lexer, reporter_, experimental_flags_);
    auto ast = parser.Parse();
    if (!parser.Success()) {
      std::string_view beginning(source_file->data().data(), 0);
      fidl::SourceSpan span(beginning, *source_file);
      const auto& error = reporter_->errors().at(0);
      size_t squiggle_size = error->span ? error->span.value().data().size() : 0;
      auto error_msg =
          fidl::reporter::Format("error", error->span, error->msg, false, squiggle_size);
      findings->emplace_back(span, "parser-error", error_msg + "\n");
      return false;
    }
    fidl::linter::Linter linter;
    if (!included_check_ids.empty()) {
      linter.set_included_checks(included_check_ids);
    }
    if (!excluded_check_ids.empty()) {
      linter.set_excluded_checks(excluded_check_ids);
    }
    linter.set_exclude_by_default(exclude_by_default);
    return linter.Lint(ast, findings, excluded_checks_not_found);
  }

  bool Lint() {
    fidl::Findings findings;
    bool passed = Lint(&findings);
    lints_ = fidl::utils::FormatFindings(findings, false);
    return passed;
  }

  std::string GenerateJSON() {
    auto json_generator = fidl::JSONGenerator(library_.get());
    auto out = json_generator.Produce();
    return out.str();
  }

  std::string GenerateTables() {
    auto tables_generator = fidl::TablesGenerator(library_.get());
    auto out = tables_generator.Produce();
    return out.str();
  }

  const fidl::flat::Bits* LookupBits(const std::string& name) {
    for (const auto& bits_decl : library_->bits_declarations_) {
      if (bits_decl->GetName() == name) {
        return bits_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Const* LookupConstant(const std::string& name) {
    for (const auto& const_decl : library_->const_declarations_) {
      if (const_decl->GetName() == name) {
        return const_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Enum* LookupEnum(const std::string& name) {
    for (const auto& enum_decl : library_->enum_declarations_) {
      if (enum_decl->GetName() == name) {
        return enum_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Resource* LookupResource(const std::string& name) {
    for (const auto& resource_decl : library_->resource_declarations_) {
      if (resource_decl->GetName() == name) {
        return resource_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Service* LookupService(const std::string& name) {
    for (const auto& service_decl : library_->service_declarations_) {
      if (service_decl->GetName() == name) {
        return service_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Struct* LookupStruct(const std::string& name) {
    for (const auto& struct_decl : library_->struct_declarations_) {
      if (struct_decl->GetName() == name) {
        return struct_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Table* LookupTable(const std::string& name) {
    for (const auto& table_decl : library_->table_declarations_) {
      if (table_decl->GetName() == name) {
        return table_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::TypeAlias* LookupTypeAlias(const std::string& name) {
    for (const auto& type_alias_decl : library_->type_alias_declarations_) {
      if (type_alias_decl->GetName() == name) {
        return type_alias_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Union* LookupUnion(const std::string& name) {
    for (const auto& union_decl : library_->union_declarations_) {
      if (union_decl->GetName() == name) {
        return union_decl.get();
      }
    }
    return nullptr;
  }

  const fidl::flat::Protocol* LookupProtocol(const std::string& name) {
    for (const auto& protocol_decl : library_->protocol_declarations_) {
      if (protocol_decl->GetName() == name) {
        return protocol_decl.get();
      }
    }
    return nullptr;
  }

  void set_warnings_as_errors(bool value) { reporter_->set_warnings_as_errors(value); }

  const fidl::flat::Library* library() const { return library_.get(); }

  const fidl::SourceFile& source_file() const {
    assert(all_sources_.size() == 1 && "convenience method only possible with single source");
    return *all_sources_.at(0);
  }

  fidl::SourceSpan source_span(size_t start, size_t size) const {
    assert(all_sources_.size() == 1 && "convenience method only possible with single source");
    std::string_view data = all_sources_.at(0)->data();
    data.remove_prefix(start);
    data.remove_suffix(data.size() - size);
    return fidl::SourceSpan(data, *all_sources_.at(0));
  }

  std::vector<fidl::Diagnostic*> diagnostics() const { return reporter_->diagnostics(); }

  const std::vector<std::unique_ptr<fidl::Diagnostic>>& errors() const {
    return reporter_->errors();
  }

  const std::vector<std::unique_ptr<fidl::Diagnostic>>& warnings() const {
    return reporter_->warnings();
  }

  const std::vector<std::string>& lints() const { return lints_; }

  const std::vector<fidl::flat::Decl*> declaration_order() const {
    return library_->declaration_order_;
  }

 protected:
  SharedAmongstLibraries owned_shared_;
  fidl::Reporter* reporter_;
  std::vector<std::string> lints_;
  fidl::ExperimentalFlags experimental_flags_;
  fidl::flat::Typespace* typespace_;
  fidl::flat::Libraries* all_libraries_;
  std::vector<std::unique_ptr<fidl::SourceFile>>* all_sources_of_all_libraries_;
  std::vector<fidl::SourceFile*> all_sources_;
  std::unique_ptr<fidl::flat::Library> library_;
};

#endif  // ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_