//===--- ConfigProvider.cpp - Loading of user configuration ---------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "ConfigProvider.h"
#include "Config.h"
#include "ConfigFragment.h"
#include "support/ThreadsafeFS.h"
#include "support/Trace.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/Path.h"
#include <chrono>
#include <mutex>

namespace clang {
namespace clangd {
namespace config {

// Threadsafe cache around reading a YAML config file from disk.
class FileConfigCache {
  std::mutex Mu;
  std::chrono::steady_clock::time_point ValidTime = {};
  llvm::SmallVector<CompiledFragment, 1> CachedValue;
  llvm::sys::TimePoint<> MTime = {};
  unsigned Size = -1;

  // Called once we are sure we want to read the file.
  // REQUIRES: Cache keys are set. Mutex must be held.
  void fillCacheFromDisk(llvm::vfs::FileSystem &FS, DiagnosticCallback DC) {
    CachedValue.clear();

    auto Buf = FS.getBufferForFile(Path);
    // If we failed to read (but stat succeeded), don't cache failure.
    if (!Buf) {
      Size = -1;
      MTime = {};
      return;
    }

    // If file changed between stat and open, we don't know its mtime.
    // For simplicity, don't cache the value in this case (use a bad key).
    if (Buf->get()->getBufferSize() != Size) {
      Size = -1;
      MTime = {};
    }

    // Finally parse and compile the actual fragments.
    for (auto &Fragment :
         Fragment::parseYAML(Buf->get()->getBuffer(), Path, DC))
      CachedValue.push_back(std::move(Fragment).compile(DC));
  }

public:
  // Must be set before the cache is used. Not a constructor param to allow
  // computing ancestor-relative paths to be deferred.
  std::string Path;

  // Retrieves up-to-date config fragments from disk.
  // A cached result may be reused if the mtime and size are unchanged.
  // (But several concurrent read()s can miss the cache after a single change).
  // Future performance ideas:
  // - allow caches to be reused based on short elapsed walltime
  // - allow latency-sensitive operations to skip revalidating the cache
  void read(const ThreadsafeFS &TFS, DiagnosticCallback DC,
            llvm::Optional<std::chrono::steady_clock::time_point> FreshTime,
            std::vector<CompiledFragment> &Out) {
    std::lock_guard<std::mutex> Lock(Mu);
    // We're going to update the cache and return whatever's in it.
    auto Return = llvm::make_scope_exit(
        [&] { llvm::copy(CachedValue, std::back_inserter(Out)); });

    // Return any sufficiently recent result without doing any further work.
    if (FreshTime && ValidTime >= FreshTime)
      return;

    // Ensure we bump the ValidTime at the end to allow for reuse.
    auto MarkTime = llvm::make_scope_exit(
        [&] { ValidTime = std::chrono::steady_clock::now(); });

    // Stat is cheaper than opening the file, it's usually unchanged.
    assert(llvm::sys::path::is_absolute(Path));
    auto FS = TFS.view(/*CWD=*/llvm::None);
    auto Stat = FS->status(Path);
    // If there's no file, the result is empty. Ensure we have an invalid key.
    if (!Stat || !Stat->isRegularFile()) {
      MTime = {};
      Size = -1;
      CachedValue.clear();
      return;
    }
    // If the modified-time and size match, assume the content does too.
    if (Size == Stat->getSize() && MTime == Stat->getLastModificationTime())
      return;

    // OK, the file has actually changed. Update cache key, compute new value.
    Size = Stat->getSize();
    MTime = Stat->getLastModificationTime();
    fillCacheFromDisk(*FS, DC);
  }
};

std::unique_ptr<Provider> Provider::fromYAMLFile(llvm::StringRef AbsPath,
                                                 const ThreadsafeFS &FS) {
  class AbsFileProvider : public Provider {
    mutable FileConfigCache Cache; // threadsafe
    const ThreadsafeFS &FS;

    std::vector<CompiledFragment>
    getFragments(const Params &P, DiagnosticCallback DC) const override {
      std::vector<CompiledFragment> Result;
      Cache.read(FS, DC, P.FreshTime, Result);
      return Result;
    };

  public:
    AbsFileProvider(llvm::StringRef Path, const ThreadsafeFS &FS) : FS(FS) {
      assert(llvm::sys::path::is_absolute(Path));
      Cache.Path = Path.str();
    }
  };

  return std::make_unique<AbsFileProvider>(AbsPath, FS);
}

std::unique_ptr<Provider>
Provider::fromAncestorRelativeYAMLFiles(llvm::StringRef RelPath,
                                        const ThreadsafeFS &FS) {
  class RelFileProvider : public Provider {
    std::string RelPath;
    const ThreadsafeFS &FS;

    mutable std::mutex Mu;
    // Keys are the ancestor directory, not the actual config path within it.
    // We only insert into this map, so pointers to values are stable forever.
    // Mutex guards the map itself, not the values (which are threadsafe).
    mutable llvm::StringMap<FileConfigCache> Cache;

    std::vector<CompiledFragment>
    getFragments(const Params &P, DiagnosticCallback DC) const override {
      namespace path = llvm::sys::path;

      if (P.Path.empty())
        return {};

      // Compute absolute paths to all ancestors (substrings of P.Path).
      llvm::StringRef Parent = path::parent_path(P.Path);
      llvm::SmallVector<llvm::StringRef, 8> Ancestors;
      for (auto I = path::begin(Parent, path::Style::posix),
                E = path::end(Parent);
           I != E; ++I) {
        // Avoid weird non-substring cases like phantom "." components.
        // In practice, Component is a substring for all "normal" ancestors.
        if (I->end() < Parent.begin() && I->end() > Parent.end())
          continue;
        Ancestors.emplace_back(Parent.begin(), I->end() - Parent.begin());
      }
      // Ensure corresponding cache entries exist in the map.
      llvm::SmallVector<FileConfigCache *, 8> Caches;
      {
        std::lock_guard<std::mutex> Lock(Mu);
        for (llvm::StringRef Ancestor : Ancestors) {
          auto R = Cache.try_emplace(Ancestor);
          // Assemble the actual config file path only once.
          if (R.second) {
            llvm::SmallString<256> ConfigPath = Ancestor;
            path::append(ConfigPath, RelPath);
            R.first->second.Path = ConfigPath.str().str();
          }
          Caches.push_back(&R.first->second);
        }
      }
      // Finally query each individual file.
      // This will take a (per-file) lock for each file that actually exists.
      std::vector<CompiledFragment> Result;
      for (FileConfigCache *Cache : Caches)
        Cache->read(FS, DC, P.FreshTime, Result);
      return Result;
    };

  public:
    RelFileProvider(llvm::StringRef RelPath, const ThreadsafeFS &FS)
        : RelPath(RelPath), FS(FS) {
      assert(llvm::sys::path::is_relative(RelPath));
    }
  };

  return std::make_unique<RelFileProvider>(RelPath, FS);
}

std::unique_ptr<Provider>
Provider::combine(std::vector<const Provider *> Providers) {
  struct CombinedProvider : Provider {
    std::vector<const Provider *> Providers;

    std::vector<CompiledFragment>
    getFragments(const Params &P, DiagnosticCallback DC) const override {
      std::vector<CompiledFragment> Result;
      for (const auto &Provider : Providers) {
        for (auto &Fragment : Provider->getFragments(P, DC))
          Result.push_back(std::move(Fragment));
      }
      return Result;
    }
  };
  auto Result = std::make_unique<CombinedProvider>();
  Result->Providers = std::move(Providers);
  return Result;
}

Config Provider::getConfig(const Params &P, DiagnosticCallback DC) const {
  trace::Span Tracer("getConfig");
  if (!P.Path.empty())
    SPAN_ATTACH(Tracer, "path", P.Path);
  Config C;
  for (const auto &Fragment : getFragments(P, DC))
    Fragment(P, C);
  return C;
}

} // namespace config
} // namespace clangd
} // namespace clang