/*
 * This source code is released into the public domain.
 */

#ifndef	LIBLFJAIL_WORDS_HH
#define	LIBLFJAIL_WORDS_HH

#include <algorithm>
#include <ranges>

#include "ctype.hh"
#include "generator.hh"

namespace lfjail {

/*
 * words: take a string-like object and split it into words using the given
 * predicate.  Empty values are discarded (i.e., repeated separators are
 * ignored).
 */

namespace detail {

template<std::ranges::range Range,
	 std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
auto split(Range &&text, Pred pred) -> std::generator<std::string>
{
	auto pos = std::ranges::begin(text);
	auto end = std::ranges::end(text);

	for (;;) {
		// Skip leading whitespace.
		pos = std::find_if_not(pos, end, pred);

		// If there's no string left, we're done.
		if (pos == end)
			break;

		// Find the end of the next word.
		auto split_pos = std::find_if(pos, end, pred);

		// Yield this word.
		co_yield std::string(pos, split_pos);
		pos = split_pos;
	}
}

template<typename Pred>
struct words_fn : std::ranges::range_adaptor_closure<words_fn<Pred>> {
	words_fn(Pred p) : _pred(std::move(p)) {}

	template<std::ranges::range Range>
	constexpr auto operator()(Range &&range) const {
		return detail::split(std::forward<Range>(range),
				     std::move(_pred));
	}

private:
	Pred _pred;
};

} // namespace detail

template<std::ranges::range Range,
	 std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
auto words(Range &&range, Pred pred)
{
	return detail::split(std::forward<Range>(range), std::move(pred));
}

template<std::ranges::viewable_range Range, std::integral Char>
auto words(Range &&range, Char ch) {
	return words(std::forward<Range>(range),
		     [ch](auto c) { return c == ch; });
}

template<std::ranges::viewable_range Range>
auto words(Range &&range) {
	return words(std::forward<Range>(range), is_c_space);
}

template<typename Pred>
requires(!std::integral<Pred> && !std::ranges::range<Pred>)
auto words(Pred pred) {
	return detail::words_fn(std::move(pred));
}

auto words() {
	return words(is_c_space);
}

template<std::integral Char>
auto words(Char ch) {
	return words([ch](auto c) { return c == ch; });
}

//constexpr words_impl words{};

} // namespace lfjail

#endif	// LIBLFJAIL_WORDS_HH