/*
 * 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).
 *
 * words() returns std::strings, while wordsv() return std::string_views
 * which refer to the original string.
 */

namespace detail {

template<typename R, typename Pred>
auto split(std::string_view text, Pred &&pred) -> std::generator<R>
{
	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 R(pos, split_pos);
		pos = split_pos;
	}
}


template<typename ValueType,
	 std::ranges::viewable_range Range,
	 std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
requires (std::ranges::contiguous_range<Range>)
struct words_view :
	std::ranges::view_interface<words_view<ValueType, Range, Pred>>
{
	words_view(auto &&base, auto &&pred) 
		: _base(std::forward<decltype(base)>(base))
		, _pred(std::forward<decltype(pred)>(pred))
		, _generator(detail::split<ValueType>(
				std::string_view(_base), _pred))
	{}

	auto begin(this auto const &self) {
		return self._generator.begin();
	}

	auto end(this auto const &self) {
		return self._generator.end();
	}

private:
	Range _base;
	Pred _pred;

	mutable std::generator<ValueType> _generator;
};

template<typename R>
struct words_impl : std::ranges::range_adaptor_closure<words_impl<R>> {
	template<std::ranges::range Range, typename Pred>
	constexpr auto operator()(Range &&range, Pred &&pred) const {
		return words_view<R, Range, Pred>(
				std::forward<decltype(range)>(range),
				std::forward<decltype(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)
	requires (std::ranges::borrowed_range<Range>)
{
	return detail::words_impl<std::string_view>{}(
		std::forward<Range>(range),
		std::forward<Pred>(pred));
}

template<std::ranges::range Range,
	 std::indirect_unary_predicate<std::ranges::iterator_t<Range>> Pred>
auto words(Range &&range, Pred &&pred)
	requires (!std::ranges::borrowed_range<Range>)
{
	return detail::words_impl<std::string>{}(
		std::forward<Range>(range),
		std::forward<Pred>(pred));
}

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

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

} // namespace lfjail

#endif	// LIBLFJAIL_WORDS_HH