#include "Completer.hh"

#include "Interpreter.hh"
#include "InterpreterOutput.hh"
#include "TclObject.hh"

#include "FileContext.hh"
#include "FileOperations.hh"
#include "foreach_file.hh"

#include "ranges.hh"
#include "stl.hh"
#include "strCat.hh"
#include "stringsp.hh"
#include "utf8_unchecked.hh"
#include "xrange.hh"

#include <algorithm>
#include <array>
#include <memory>

namespace openmsx {

static bool formatHelper(std::span<const std::string_view> input, size_t columnLimit,
                         std::vector<std::string>& result)
{
	size_t column = 0;
	auto it = begin(input);
	do {
		size_t maxColumn = column;
		for (size_t i = 0; (i < result.size()) && (it != end(input));
		     ++i, ++it) {
			auto curSize = utf8::unchecked::size(result[i]);
			strAppend(result[i], spaces(column - curSize), *it);
			maxColumn = std::max(maxColumn,
			                     utf8::unchecked::size(result[i]));
			if (maxColumn > columnLimit) return false;
		}
		column = maxColumn + 2;
	} while (it != end(input));
	return true;
}

static std::vector<std::string> format(std::span<const std::string_view> input, size_t columnLimit)
{
	std::vector<std::string> result;
	for (auto lines : xrange(1u, input.size())) {
		result.assign(lines, std::string());
		if (formatHelper(input, columnLimit, result)) {
			return result;
		}
	}
	append(result, input);
	return result;
}

std::vector<std::string> Completer::formatListInColumns(std::span<const std::string_view> input)
{
	return format(input, output->getOutputColumns() - 1);
}

bool Completer::equalHead(std::string_view s, const CompletionCandidate& c)
{
	if (c.text.size() < s.size()) return false;
	if (c.caseSensitive) {
		return std::ranges::equal(s, subspan(c.text, 0, s.size()));
	} else {
		return strncasecmp(s.data(), c.text.data(), s.size()) == 0;
	}
}

void Completer::completeImpl(std::vector<std::string>& tokens, std::vector<CompletionCandidate> matches)
{
	auto& str = tokens.back();
	assert(std::ranges::all_of(matches, [&](auto& m) { return equalHead(str, m); }));

	if (matches.empty()) {
		// no matching values
		return;
	}
	if (matches.size() == 1) {
		// only one match
		auto& m = matches.front();
		str = m.text;
		if (!m.partial) {
			tokens.emplace_back();
		}
		return;
	}

	// Sort and remove duplicates.
	//  For efficiency it's best if the list doesn't contain duplicates to
	//  start with. Though sometimes this is hard to avoid. E.g. when doing
	//  filename completion + some extra allowed strings and one of these
	//  extra strings is the same as one of the filenames.
	std::ranges::sort(matches, {}, &CompletionCandidate::text);
	auto u = std::ranges::unique(matches, {}, &CompletionCandidate::text);
	matches.erase(u.begin(), u.end());

	auto minsize_of_matches = std::ranges::min(
		matches, {}, [](const auto& m) { return m.text.size(); }).text.size();

	bool expanded = false;
	while (str.size() < minsize_of_matches) {
		auto it = begin(matches);
		auto b = begin(it->text);
		auto e = b + str.size();
		utf8::unchecked::next(e);
		std::string_view test_str(b, e);
		if (!std::ranges::all_of(matches, [&](auto& val) { return equalHead(test_str, val); })) {
			break;
		}
		str = test_str;
		expanded = true;
	}
	if (!expanded && output) {
		output->setCompletions(matches);
	}
}

void Completer::completeFileNameImpl(std::vector<std::string>& tokens,
                                     const FileContext& context,
                                     std::vector<CompletionCandidate> matches)
{
	std::string& filename = tokens.back();
	filename = FileOperations::expandTilde(std::move(filename));
	filename = FileOperations::expandCurrentDirFromDrive(std::move(filename));
	std::string_view dirname1 = FileOperations::getDirName(filename);

	std::span<const std::string> paths;
	if (FileOperations::isAbsolutePath(filename)) {
		static const std::array<std::string, 1> EMPTY = {""};
		paths = EMPTY;
	} else {
		paths = context.getPaths();
	}

	for (const auto& p : paths) {
		auto pLen = p.size();
		if (!p.empty() && (p.back() != '/')) ++pLen;

		auto fileAction = [&](std::string_view path, bool isDir = false) {
			const auto& nm = FileOperations::getConventionalPath(
				std::string(path.substr(pLen)));
			CompletionCandidate c = {.text = nm};
			if (isDir) c.text += '/';
			if (equalHead(filename, c)) {
				c.display_ = FileOperations::getFilename(nm);
				if (isDir) {
					c.display_ += '/';
					c.partial = true;
				}
				matches.push_back(std::move(c));
			}
		};
		auto dirAction = [&](std::string& path) {
			fileAction(path, true);
		};

		foreach_file_and_directory(
			FileOperations::join(p, dirname1),
			fileAction, dirAction);
	}
	completeImpl(tokens, std::move(matches));
}

void Completer::checkNumArgs(std::span<const TclObject> tokens, unsigned exactly, const char* errMessage) const
{
	checkNumArgs(tokens, exactly, Prefix{exactly - 1}, errMessage);
}

void Completer::checkNumArgs(std::span<const TclObject> tokens, AtLeast atLeast, const char* errMessage) const
{
	checkNumArgs(tokens, atLeast, Prefix{atLeast.min - 1}, errMessage);
}

void Completer::checkNumArgs(std::span<const TclObject> tokens, Between between, const char* errMessage) const
{
	checkNumArgs(tokens, between, Prefix{between.min - 1}, errMessage);
}

void Completer::checkNumArgs(std::span<const TclObject> tokens, unsigned exactly, Prefix prefix, const char* errMessage) const
{
	if (tokens.size() == exactly) return;
	getInterpreter().wrongNumArgs(prefix.n, tokens, errMessage);
}

void Completer::checkNumArgs(std::span<const TclObject> tokens, AtLeast atLeast, Prefix prefix, const char* errMessage) const
{
	if (tokens.size() >= atLeast.min) return;
	getInterpreter().wrongNumArgs(prefix.n, tokens, errMessage);
}

void Completer::checkNumArgs(std::span<const TclObject> tokens, Between between, Prefix prefix, const char* errMessage) const
{
	if (tokens.size() >= between.min && tokens.size() <= between.max) return;
	getInterpreter().wrongNumArgs(prefix.n, tokens, errMessage);
}

} // namespace openmsx