#pragma once

#include <abnf/forward.h>
#include <abnf/grammar.h>
#include <cstddef>

namespace abnf {
char_range parse_char_range(std::string_view);
}

namespace abnf::literals {
inline literal operator""_lit(char const * const str, size_t len) {
  return literal{{str, len}};
}

inline reference operator""_ref(char const * const str, size_t len) {
  return reference{{str, len}};
}

inline char_range operator""_range(char const * const str, size_t len) {
  return parse_char_range({str, len});
}

inline one_of operator/(one_of lhs, rule rhs) {
  lhs.rules.push_back(std::move(rhs));
  return lhs;
}

inline one_of operator/(rule_like auto const & lhs,
                        rule_like auto const & rhs) {
  return one_of{rule{lhs}, rule{rhs}};
}

inline rule operator+(rule lhs, rule_part const & rhs) {
  lhs.rules.push_back(rhs);
  return lhs;
}

inline rule operator+(rule_part_like auto const & lhs, rule_part const & rhs) {
  return rule{lhs, rhs};
}

inline repeated operator*(rule v) { return repeated{v}; }
}