#pragma once

#include <iosfwd>
#include <type_traits>
#include <variant>

namespace abnf::detail {
template <typename, typename> struct in_variant : std::false_type {};
template <typename T, typename... Ts>
struct in_variant<T, std::variant<Ts...>>
    : std::disjunction<std::is_same<T, Ts>...> {};
}

namespace abnf {
struct literal;
struct reference;
struct char_range;
struct repeated;
struct one_of;

struct rule;
using rule_part =
    std::variant<literal, char_range, reference, repeated, one_of>;

class grammar_base;
class grammar_group;
class grammar;

grammar parse(std::istream & in);
grammar parse(std::istream && in);
grammar_group parse_group(std::istream & in);
grammar_group parse_group(std::istream && in);

std::ostream & operator<<(std::ostream & os, rule const & rule);
std::ostream & operator<<(std::ostream & os, grammar_base const & grammar);
std::ostream & operator<<(std::ostream & os, grammar const & grammar);

template <typename T>
concept rule_part_like = detail::in_variant<T, rule_part>::value;

template <typename T>
concept rule_like =
    std::is_constructible_v<rule_part, T> || std::is_same_v<rule, T>;
}