import { describe, expect, it } from "vitest";
import { Message } from "./message";
import {
	extractVariablesFromMessages,
	extractVariablesFromText,
	mergeVariables,
	replaceVariablesInMessages,
	replaceVariablesInText,
} from "./variables";

// =============================================================================
// extractVariablesFromText
// =============================================================================

describe("extractVariablesFromText", () => {
	it("extracts a single variable", () => {
		expect(extractVariablesFromText("Hello {{ name }}")).toEqual(["name"]);
	});

	it("extracts multiple distinct variables", () => {
		expect(extractVariablesFromText("{{ greeting }}, {{ name }}!")).toEqual(["greeting", "name"]);
	});

	it("deduplicates repeated variables", () => {
		expect(extractVariablesFromText("{{ x }} and {{ x }}")).toEqual(["x"]);
	});

	it("returns empty array when no variables exist", () => {
		expect(extractVariablesFromText("Hello world")).toEqual([]);
	});

	it("returns empty array for empty string", () => {
		expect(extractVariablesFromText("")).toEqual([]);
	});

	it("handles variable with no spaces inside braces", () => {
		expect(extractVariablesFromText("{{name}}")).toEqual(["name"]);
	});

	it("handles variable with extra whitespace inside braces", () => {
		expect(extractVariablesFromText("{{   name   }}")).toEqual(["name"]);
	});

	it("handles underscored variable names", () => {
		expect(extractVariablesFromText("{{ user_name }}")).toEqual(["user_name"]);
	});

	it("handles dot-notation variable names", () => {
		expect(extractVariablesFromText("{{ user.name }}")).toEqual(["user.name"]);
	});

	it("handles variables with numbers in name", () => {
		expect(extractVariablesFromText("{{ item1 }} {{ item2 }}")).toEqual(["item1", "item2"]);
	});

	it("handles variable starting with underscore", () => {
		expect(extractVariablesFromText("{{ _private }}")).toEqual(["_private"]);
	});

	it("does not extract variables starting with a number", () => {
		expect(extractVariablesFromText("{{ 1abc }}")).toEqual([]);
	});

	it("does not extract variables with special characters", () => {
		expect(extractVariablesFromText("{{ na-me }}")).toEqual([]);
	});

	it("handles multiline text with variables", () => {
		const text = `Line one {{ first }}
Line two {{ second }}
Line three`;
		expect(extractVariablesFromText(text)).toEqual(["first", "second"]);
	});

	it("ignores jinja2 block tags", () => {
		expect(extractVariablesFromText("{% if condition %}yes{% endif %}")).toEqual([]);
	});

	it("ignores jinja2 comments", () => {
		expect(extractVariablesFromText("{# this is a comment #}")).toEqual([]);
	});

	it("extracts variables adjacent to jinja2 block tags", () => {
		const text = "{% if show %}{{ name }}{% endif %}";
		expect(extractVariablesFromText(text)).toEqual(["name"]);
	});

	it("handles triple braces (not valid jinja2) gracefully", () => {
		// {{{ name }}} — the regex should still find "name" from the inner {{ }}
		const result = extractVariablesFromText("{{{ name }}}");
		expect(result).toEqual(["name"]);
	});

	it("handles variables embedded in longer text", () => {
		const text = "Dear {{ title }} {{ last_name }}, your order #{{ order_id }} is ready.";
		expect(extractVariablesFromText(text)).toEqual(["title", "last_name", "order_id"]);
	});

	// Regression: calling extractVariablesFromText consecutively should work
	// (ensures regex lastIndex is properly reset)
	it("works correctly when called multiple times in succession", () => {
		expect(extractVariablesFromText("{{ a }}")).toEqual(["a"]);
		expect(extractVariablesFromText("{{ b }}")).toEqual(["b"]);
		expect(extractVariablesFromText("{{ a }} {{ c }}")).toEqual(["a", "c"]);
	});
});

// =============================================================================
// extractVariablesFromMessages
// =============================================================================

describe("extractVariablesFromMessages", () => {
	it("extracts variables from a system message", () => {
		const messages = [Message.system("You are {{ role }}")];
		expect(extractVariablesFromMessages(messages)).toEqual(["role"]);
	});

	it("extracts variables from a user message", () => {
		const messages = [Message.request("Tell me about {{ topic }}")];
		expect(extractVariablesFromMessages(messages)).toEqual(["topic"]);
	});

	it("extracts variables from an assistant message", () => {
		const messages = [Message.response("Hello {{ name }}")];
		expect(extractVariablesFromMessages(messages)).toEqual([]);
	});

	it("extracts variables across multiple messages", () => {
		const messages = [
			Message.system("You are {{ role }}"),
			Message.request("Tell me about {{ topic }}"),
			Message.response("The {{ topic }} is interesting"),
		];
		expect(extractVariablesFromMessages(messages)).toEqual(["role", "topic"]);
	});

	it("deduplicates across messages", () => {
		const messages = [Message.system("{{ name }}"), Message.request("{{ name }}")];
		expect(extractVariablesFromMessages(messages)).toEqual(["name"]);
	});

	it("returns empty array when no messages have variables", () => {
		const messages = [Message.system("You are a helpful assistant"), Message.request("Hello")];
		expect(extractVariablesFromMessages(messages)).toEqual([]);
	});

	it("returns empty array for empty messages array", () => {
		expect(extractVariablesFromMessages([])).toEqual([]);
	});

	it("handles messages with empty content", () => {
		const messages = [Message.system("")];
		expect(extractVariablesFromMessages(messages)).toEqual([]);
	});

	it("handles error messages gracefully", () => {
		const messages = [Message.error("Something went wrong")];
		expect(extractVariablesFromMessages(messages)).toEqual([]);
	});
});

// =============================================================================
// replaceVariablesInText
// =============================================================================

describe("replaceVariablesInText", () => {
	it("replaces a single variable", () => {
		expect(replaceVariablesInText("Hello {{ name }}", { name: "World" })).toBe("Hello World");
	});

	it("replaces multiple variables", () => {
		const result = replaceVariablesInText("{{ greeting }}, {{ name }}!", {
			greeting: "Hi",
			name: "Alice",
		});
		expect(result).toBe("Hi, Alice!");
	});

	it("replaces all occurrences of the same variable", () => {
		expect(replaceVariablesInText("{{ x }} and {{ x }}", { x: "yes" })).toBe("yes and yes");
	});

	it("preserves leading curly braces that are not part of variables", () => {
		expect(replaceVariablesInText("{{{ x }} and {{ x }}", { x: "yes" })).toBe("{yes and yes");
	});

	it("preserves trailing curly braces that are not part of variables", () => {
		expect(replaceVariablesInText("{{ x }} and {{ x }}}}", { x: "yes" })).toBe("yes and yes}}");
	});

	it("leaves variable untouched when not in map", () => {
		expect(replaceVariablesInText("{{ unknown }}", {})).toBe("{{ unknown }}");
	});

	it("leaves variable untouched when value is empty string", () => {
		expect(replaceVariablesInText("{{ name }}", { name: "" })).toBe("{{ name }}");
	});

	it("returns original text when no variables present", () => {
		expect(replaceVariablesInText("Hello world", { name: "test" })).toBe("Hello world");
	});

	it("returns empty string for empty input", () => {
		expect(replaceVariablesInText("", { name: "test" })).toBe("");
	});

	it("handles replacement value containing special regex characters", () => {
		expect(replaceVariablesInText("{{ val }}", { val: "$100.00" })).toBe("$100.00");
	});

	it("handles replacement value containing curly braces", () => {
		expect(replaceVariablesInText("{{ val }}", { val: "{{ nested }}" })).toBe("{{ nested }}");
	});

	it("handles variable with no spaces in braces", () => {
		expect(replaceVariablesInText("{{name}}", { name: "Bob" })).toBe("Bob");
	});

	it("handles variable with extra whitespace in braces", () => {
		expect(replaceVariablesInText("{{   name   }}", { name: "Bob" })).toBe("Bob");
	});

	it("replaces only known variables and leaves others", () => {
		const result = replaceVariablesInText("{{ known }} and {{ unknown }}", { known: "yes" });
		expect(result).toBe("yes and {{ unknown }}");
	});

	it("handles multiline text replacement", () => {
		const text = `Hello {{ name }},
Your order {{ order_id }} is ready.`;
		const result = replaceVariablesInText(text, { name: "Alice", order_id: "12345" });
		expect(result).toBe(`Hello Alice,
Your order 12345 is ready.`);
	});

	it("handles dot-notation variables", () => {
		expect(replaceVariablesInText("{{ user.name }}", { "user.name": "Alice" })).toBe("Alice");
	});

	// Regression: consecutive calls should work (lastIndex reset)
	it("works correctly when called multiple times in succession", () => {
		expect(replaceVariablesInText("{{ a }}", { a: "1" })).toBe("1");
		expect(replaceVariablesInText("{{ b }}", { b: "2" })).toBe("2");
	});
});

// =============================================================================
// replaceVariablesInMessages
// =============================================================================

describe("replaceVariablesInMessages", () => {
	it("replaces variables in message content", () => {
		const messages = [Message.system("You are {{ role }}")];
		const result = replaceVariablesInMessages(messages, { role: "a pirate" });
		expect(result[0].content).toBe("You are a pirate");
	});

	it("does not mutate original messages", () => {
		const messages = [Message.system("You are {{ role }}")];
		replaceVariablesInMessages(messages, { role: "a pirate" });
		expect(messages[0].content).toBe("You are {{ role }}");
	});

	it("returns original messages array when all variable values are empty", () => {
		const messages = [Message.system("You are {{ role }}")];
		const result = replaceVariablesInMessages(messages, { role: "" });
		expect(result).toBe(messages); // same reference — fast path
	});

	it("returns original messages array when variables map is empty", () => {
		const messages = [Message.system("You are {{ role }}")];
		const result = replaceVariablesInMessages(messages, {});
		expect(result).toBe(messages);
	});

	it("replaces variables across multiple messages", () => {
		const messages = [Message.system("You are {{ role }}"), Message.request("Tell me about {{ topic }}")];
		const result = replaceVariablesInMessages(messages, { role: "a teacher", topic: "math" });
		expect(result[0].content).toBe("You are a teacher");
		expect(result[1].content).toBe("Tell me about math");
	});

	it("preserves messages without variables unchanged", () => {
		const messages = [Message.system("Hello"), Message.request("{{ name }}")];
		const result = replaceVariablesInMessages(messages, { name: "Alice" });
		expect(result[0].content).toBe("Hello");
		expect(result[1].content).toBe("Alice");
	});

	it("preserves message count", () => {
		const messages = [Message.system("{{ a }}"), Message.request("{{ b }}"), Message.response("{{ c }}")];
		const result = replaceVariablesInMessages(messages, { a: "1", b: "2", c: "3" });
		expect(result).toHaveLength(3);
	});

	it("handles empty messages array", () => {
		const result = replaceVariablesInMessages([], { name: "Alice" });
		expect(result).toEqual([]);
	});

	it("handles messages with empty content", () => {
		const messages = [Message.system("")];
		const result = replaceVariablesInMessages(messages, { name: "Alice" });
		expect(result[0].content).toBe("");
	});
});

// =============================================================================
// mergeVariables
// =============================================================================

describe("mergeVariables", () => {
	it("creates entries for new variable names with empty values", () => {
		expect(mergeVariables({}, ["name", "topic"])).toEqual({
			name: "",
			topic: "",
		});
	});

	it("preserves existing values for variables that still exist", () => {
		const current = { name: "Alice", topic: "math" };
		const result = mergeVariables(current, ["name", "topic"]);
		expect(result).toEqual({ name: "Alice", topic: "math" });
	});

	it("drops variables no longer in the new names list", () => {
		const current = { name: "Alice", old_var: "value" };
		const result = mergeVariables(current, ["name"]);
		expect(result).toEqual({ name: "Alice" });
		expect(result).not.toHaveProperty("old_var");
	});

	it("adds new variables while preserving existing ones", () => {
		const current = { name: "Alice" };
		const result = mergeVariables(current, ["name", "topic"]);
		expect(result).toEqual({ name: "Alice", topic: "" });
	});

	it("handles empty current variables", () => {
		expect(mergeVariables({}, ["a", "b"])).toEqual({ a: "", b: "" });
	});

	it("handles empty new names (returns empty map)", () => {
		const current = { name: "Alice", topic: "math" };
		expect(mergeVariables(current, [])).toEqual({});
	});

	it("handles both empty", () => {
		expect(mergeVariables({}, [])).toEqual({});
	});

	it("does not mutate the original variables map", () => {
		const current = { name: "Alice" };
		mergeVariables(current, ["name", "topic"]);
		expect(current).toEqual({ name: "Alice" });
	});

	it("preserves empty string values for existing variables", () => {
		const current = { name: "" };
		const result = mergeVariables(current, ["name"]);
		expect(result).toEqual({ name: "" });
	});
});