// https://en.cppreference.com/w/cpp/keyword
// Should be manually updated

import { AttributeIndex, KeywordIndex } from "./typing";

const KEYWORDS = [
  { keyword: "alignas", since: "c++11" },
  { keyword: "alignof", since: "c++11" },
  { keyword: "and" },
  { keyword: "and_eq" },
  { keyword: "asm" },
  { keyword: "atomic_cancel", ts: "tm" },
  { keyword: "atomic_commit", ts: "tm" },
  { keyword: "atomic_noexcept", ts: "tm" },
  { keyword: "auto" },
  { keyword: "bitand" },
  { keyword: "bitor" },
  { keyword: "bool" },
  { keyword: "break" },
  { keyword: "case" },
  { keyword: "catch" },
  { keyword: "char" },
  { keyword: "char8_t", since: "c++20" },
  { keyword: "char16_t", since: "c++11" },
  { keyword: "char32_t", since: "c++11" },
  { keyword: "class" },
  { keyword: "compl" },
  { keyword: "concept", since: "c++20" },
  { keyword: "const" },
  { keyword: "consteval", since: "c++20" },
  { keyword: "constexpr", since: "c++11" },
  { keyword: "constinit", since: "c++20" },
  { keyword: "const_cast" },
  { keyword: "continue" },
  { keyword: "co_await", since: "c++20" },
  { keyword: "co_return", since: "c++20" },
  { keyword: "co_yield", since: "c++20" },
  { keyword: "decltype", since: "c++11" },
  { keyword: "default" },
  { keyword: "delete" },
  { keyword: "do" },
  { keyword: "double" },
  { keyword: "dynamic_cast" },
  { keyword: "else" },
  { keyword: "enum" },
  { keyword: "explicit" },
  { keyword: "export" },
  { keyword: "extern" },
  { keyword: "false" },
  { keyword: "float" },
  { keyword: "for" },
  { keyword: "friend" },
  { keyword: "goto" },
  { keyword: "if" },
  { keyword: "inline" },
  { keyword: "int" },
  { keyword: "long" },
  { keyword: "mutable" },
  { keyword: "namespace" },
  { keyword: "new" },
  { keyword: "noexcept", since: "c++11" },
  { keyword: "not" },
  { keyword: "not_eq" },
  { keyword: "nullptr", since: "c++11" },
  { keyword: "operator" },
  { keyword: "or" },
  { keyword: "or_eq" },
  { keyword: "private" },
  { keyword: "protected" },
  { keyword: "public" },
  { keyword: "reflexpr", ts: "reflection" },
  { keyword: "register" },
  { keyword: "reinterpret_cast" },
  { keyword: "requires", since: "c++20" },
  { keyword: "return" },
  { keyword: "short" },
  { keyword: "signed" },
  { keyword: "sizeof" },
  { keyword: "static" },
  { keyword: "static_assert", since: "c++11" },
  { keyword: "static_cast" },
  { keyword: "struct" },
  { keyword: "switch" },
  { keyword: "synchronized", ts: "tm" },
  { keyword: "template" },
  { keyword: "this" },
  { keyword: "thread_local", since: "c++11" },
  { keyword: "throw" },
  { keyword: "true" },
  { keyword: "try" },
  { keyword: "typedef" },
  { keyword: "typeid" },
  { keyword: "typename" },
  { keyword: "union" },
  { keyword: "unsigned" },
  { keyword: "using" },
  { keyword: "virtual" },
  { keyword: "void" },
  { keyword: "volatile" },
  { keyword: "wchar_t" },
  { keyword: "while" },
  { keyword: "xor" },
  { keyword: "xor_eq" },
];

const IDENTIFIERS_W_SPECIAL_MEANING = [
  { keyword: "final", since: "c++11", link: "cpp/language/final" },
  { keyword: "override", since: "c++11", link: "cpp/language/override" },
  {
    keyword: "transaction_safe",
    ts: "tm",
    link: "cpp/language/transactional_memory",
  },
  {
    keyword: "transaction_safe_dynamic",
    ts: "tm",
    link: "cpp/language/transactional_memory",
  },
  { keyword: "import", since: "c++20", link: "cpp/keyword/import" },
  { keyword: "module", since: "c++20", link: "cpp/keyword/module" },
];

export function getKeywords(): KeywordIndex[] {
  return [
    ...KEYWORDS.map<KeywordIndex>((w) => ({
      type: "keyword",
      name: w.keyword,
      marks: {
        since: w.ts ?? w.since,
      },
      link: `cpp/keyword/${w.keyword}`,
      canBeUsedAsIdentifier: false,
    })),
    ...IDENTIFIERS_W_SPECIAL_MEANING.map<KeywordIndex>((w) => ({
      type: "keyword",
      name: w.keyword,
      marks: {
        since: w.ts ?? w.since,
      },
      link: w.link,
      canBeUsedAsIdentifier: false,
    })),
  ];
}

const STD_ATTRIBUTES = [
  { attr: "noreturn", since: "c++11" },
  { attr: "carries_dependency", since: "c++11" },
  { attr: "deprecated", since: "c++14" },
  { attr: "fallthrough", since: "c++17" },
  { attr: "nodiscard", since: "c++17" },
  { attr: "maybe_unused", since: "c++17" },
  { attr: "likely", since: "c++20" },
  { attr: "unlikely", link: "cpp/language/attributes/likely", since: "c++20" },
  { attr: "no_unique_address", since: "c++20" },
  { attr: "assume", since: "c++23" },
  { attr: "optimize_for_synchronized", ts: "tm" },
];

export function getStdAttributes(): AttributeIndex[] {
  return STD_ATTRIBUTES.map<AttributeIndex>((a) => ({
    type: "attribute",
    namespace: "",
    name: `[[${a.attr}]]`,
    link: a.link ?? `cpp/language/attributes/${a.attr}`,
    marks: {
      since: a.ts ?? a.since,
    },
  }));
}