use bufio;
use common;
use common::{token, ltok, nonterminal};
use fmt;
use glue;
use io;
use memio;
use strings;

// A captured variable from [[match_tokens]]
export type capture = struct {
	start: common::location,	// Inclusive
	end: common::location,		// Exclusive
	kind: nonterminal,
	name: str,
	text: str,
	data: nullable *opaque,
};

// Retrieves the text string from the source file between two locations. The
// return value is borrowed from the context.
export fn get_text(ctx: *context, start: common::location, end: common::location) str = {
	const buffer = memio::buffer(ctx.buffer);
	const data = buffer[start.off..end.off];
	return strings::fromutf8(data)!;
};

// Retrieves the text string from the source file associated with a capture. The
// return value is borrowed from the context.
export fn capture_gettext(ctx: *context, cap: *capture) str = {
	return get_text(ctx, cap.start, cap.end);
};

// Result of [[match_tokens]]
export type captures = struct {
	start: common::location,
	end: common::location,
	vars: []capture,
};

// Retrieves a variable from a [[captures]] list.
export fn getvar(c: *captures, name: str) const *capture = {
	for (let var &.. c.vars) {
		if (var.name == name) {
			return var;
		};
	};
	fmt::fatalf("Invalid capture variable name '{}'", name);
};

// Frees state associated with [[captures]].
export fn captures_finish(glue: *glue::glue, c: *captures) void = {
	for (let var &.. c.vars) {
		free(var.name);
		glue.free_nonterminal(var.kind, var.data);
	};
	free(c.vars);
	c.vars = [];
};

// Matches a token pattern (or patterns) against a lexer.
export fn match_pattern(
	ctx: *context,
	vars: *captures,
	patterns: str...
) (bool | common::error) = {
	for (let pat .. patterns) {
		const rp = ctx.glue.lex_save(ctx.lex);
		captures_finish(ctx.glue, vars);

		if (_match_pattern(ctx, vars, pat)?) {
			free(rp);
			return true;
		};

		ctx.glue.lex_restore(ctx.lex, rp);
	};
	return false;
};

fn _match_pattern(
	ctx: *context,
	vars: *captures,
	pat: str,
) (bool | common::error) = {
	const glue = ctx.glue;
	const lex = ctx.lex;
	vars.start = glue.lex_mkloc(lex);
	defer vars.end = glue.lex_mkloc(lex);

	const in = memio::fixed(strings::toutf8(pat));
	const scan = bufio::newscanner(&in);
	defer bufio::finish(&scan);
	const ref = glue.lex_init(&scan, "<reference>");
	defer glue.lex_free(ref);

	for (true) {
		let ref_tok = glue.lex_lex(ref)!;
		switch (ref_tok.0) {
		case ltok::EOF =>
			break;
		case ltok::DOLLAR =>
			let var = parse_variable(glue, ref);
			var.start = glue.lex_mkloc(lex);

			if (var.name == "*") {
				ref_tok = glue.lex_lex(ref)!;
				assert(ref_tok.0 != ltok::EOF);
				scan_until(ctx, lex, ref_tok);
				continue;
			};

			match (glue.parse_nonterminal(lex, var.kind)) {
			case let data: nullable *opaque =>
				var.data = data;
				var.end = glue.lex_mkloc(lex);
			case common::error =>
				free(var.name);
				return false;
			};

			var.text = capture_gettext(ctx, &var);
			append(vars.vars, var)!;
			continue;
		case => void;
		};

		const tok = glue.lex_lex(lex)?;
		if (ref_tok.0 != tok.0) {
			glue.lex_unlex(lex, tok);
			return false;
		};
		switch (ref_tok.0) {
		case ltok::NAME =>
			const ref_name = ref_tok.1 as str;
			const name = tok.1 as str;
			if (name != ref_name) {
				glue.lex_unlex(lex, tok);
				return false;
			};
		case => void;
		};

		if (vars.start.line == 0) {
			vars.start = tok.2;
		};
	};

	vars.end = glue.lex_mkloc(lex);
	return true;
};

fn parse_variable(
	glue: *glue::glue,
	ref: *glue::lexer,
) capture = {
	let var = capture { ... };

	let tok = glue.lex_lex(ref)!;
	switch (tok.0) {
	case ltok::NAME =>
		var.name = strings::dup(tok.1 as str)!;
		return var;
	case ltok::TIMES =>
		var.name = strings::dup("*")!;
		return var;
	case ltok::LBRACE => void;
	case => abort("Invalid match pattern");
	};

	tok = glue.lex_lex(ref)!;
	switch (tok.0) {
	case ltok::NAME =>
		var.name = strings::dup(tok.1 as str)!;
		tok = glue.lex_lex(ref)!;
	case => void;
	};

	switch (tok.0) {
	case ltok::RBRACE =>
		assert(var.name != "", "Invalid match pattern");
		return var;
	case ltok::COLON => void;
	case => abort("Invalid match pattern");
	};

	tok = glue.lex_lex(ref)!;
	assert(tok.0 == ltok::LIT_STR, "Invalid match pattern");

	var.kind = common::str_to_nonterminal(tok.1 as str);
	assert(var.kind != nonterminal::NONE, "Invalid match pattern");

	tok = glue.lex_lex(ref)!;
	assert(tok.0 == ltok::RBRACE, "Invalid match pattern");
	return var;
};

fn scan_until(
	ctx: *context,
	lex: *glue::lexer,
	tok: token,
) void = {
	assert(tok.1 is void); // TODO?

	for (true) {
		let next = ctx.glue.lex_lex(lex)!;
		if (next.0 == tok.0) {
			break;
		};
	};
};