local libName = 'Module:Reply to'
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()
local frame = mw.getCurrentFrame()

-- Helper to run all tests using sandbox version of the library from the debug console. To run against main lib, use =p.run()
function suite.runSandbox()
	return suite.run(frame:newChild{
		title = libName .. '/testcases',
		args = {
			module = libName .. '/sandbox',
			displayMode = 'log'
		},
	})
end

-- Allow test runner to use both the main library and the sandbox of the library with the same testcases
function suite:module()
	return self.frame and self.frame.args.module or libName
end

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function makeFrameWithParentArgs(args)
	local parent = frame:newChild{title = 'Template:Reply to', args = args}
	local child = parent:newChild{title = 'Module:Reply to'}
	return child
end

local function replyTo(args)
	return require(suite:module()).replyto(makeFrameWithParentArgs(args))
end

-- Returns an array of n unique strings.
local function makeNUniqueStrings(n)
	local ret = {}
	for i = 1, n do
		ret[i] = tostring(i)
	end
	return ret
end

function suite:assertHtmlError(pattern, output)
	pattern = '^<strong class="error">Error in %[%[Template:Reply to%]%]: ' .. pattern .. '.</strong>$'
	self:assertStringContains(pattern, output, nil, 1)
end

function suite:assertContentEquals(expected, actual)
	expected = '<span class="template-ping">' .. expected .. '</span>'
	self:assertEquals(mw.text.trim(expected), mw.text.trim(actual), nil, 1)
end

--------------------------------------------------------------------------------
-- Error tests
--------------------------------------------------------------------------------

function suite:testNoUsernamesError()
	self:assertHtmlError('Username not given', replyTo{})
end

function suite:testInvalidUsernameError()
	self:assertHtmlError("Input contains forbidden characters", replyTo{'Examp|le'})
end

function suite:testTooManyUsernamesError()
	self:assertHtmlError(
		'More than %d+ names specified',
		replyTo(makeNUniqueStrings(1000)) -- The limit is probably always going to be lower than 1000
	)
end

--------------------------------------------------------------------------------
-- Test defaults
--------------------------------------------------------------------------------

function suite:testOneUsername()
	self:assertContentEquals(
		'@[[User:Example|Example]]:',
		replyTo{'Example'}
	)
end

function suite:testTwoUsernames()
	self:assertContentEquals(
		'@[[User:Example|Example]] and [[User:Example2|Example2]]:',
		replyTo{'Example', 'Example2'}
	)
end

function suite:testThreeUsernames()
	self:assertContentEquals(
		'@[[User:Example|Example]], [[User:Example2|Example2]],  and [[User:Example3|Example3]]:',
		replyTo{'Example', 'Example2', 'Example3'}
	)
end

function suite:testFourUsernames()
	self:assertContentEquals(
		'@[[User:Example|Example]], [[User:Example2|Example2]], [[User:Example3|Example3]],  and [[User:Example4|Example4]]:',
		replyTo{'Example', 'Example2', 'Example3', 'Example4'}
	)
end

--------------------------------------------------------------------------------
-- Test labels
--------------------------------------------------------------------------------

function suite:testLabel()
	self:assertContentEquals(
		'@[[User:Example|Foo]]:',
		replyTo{[1] = 'Example', label = 'Foo'}
	)
end

function suite:testLabel1()
	self:assertContentEquals(
		'@[[User:Example|Foo]]:',
		replyTo{[1] = 'Example', label1 = 'Foo'}
	)
end

function suite:testTwoLabels()
	self:assertContentEquals(
		'@[[User:Example|Foo]] and [[User:Example2|Bar]]:',
		replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar'}
	)
end

function suite:testThreeLabels()
	self:assertContentEquals(
		'@[[User:Example|Foo]], [[User:Example2|Bar]],  and [[User:Example3|Baz]]:',
		replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}
	)
end

function suite:testTempAccountLabel()
	self:assertContentEquals(
		'@[[User:~2025-12345-67|&#x200B;]][[User talk:~2025-12345-67|~2025-12345-67]]:',
		replyTo{[1] = '~2025-12345-67'}
	)
end

--------------------------------------------------------------------------------
-- Test special formatting
--------------------------------------------------------------------------------

function suite:testPrefix()
	self:assertContentEquals(
		'foo[[User:Example|Example]]:',
		replyTo{'Example', prefix = 'foo'}
	)
end

function suite:testBlankPrefix()
	self:assertContentEquals(
		'[[User:Example|Example]]:',
		replyTo{'Example', prefix = ''}
	)
end

function suite:testConjunction()
	self:assertContentEquals(
		'@[[User:Example|Example]], [[User:Example2|Example2]],  foo [[User:Example3|Example3]]:',
		replyTo{'Example', 'Example2', 'Example3', c = 'foo'}
	)
end

function suite:testBlankConjunction()
	self:assertContentEquals(
		'@[[User:Example|Example]], [[User:Example2|Example2]],   [[User:Example3|Example3]]:',
		replyTo{'Example', 'Example2', 'Example3', c = ''}
	)
end

function suite:testPunctuation()
	self:assertContentEquals(
		'@[[User:Example|Example]]foo',
		replyTo{'Example', p = 'foo'}
	)
end

function suite:testBlankPunctuation()
	self:assertContentEquals(
		'@[[User:Example|Example]]',
		replyTo{'Example', p = ''}
	)
end

--------------------------------------------------------------------------------
-- Test non-standard parameter orders
--------------------------------------------------------------------------------

function suite:testNoFirstParam()
	self:assertContentEquals(
		'@[[User:Example|Example]]:',
		replyTo{[2] = 'Example'}
	)
end

function suite:testNoFirstParamWithLabel()
	self:assertContentEquals(
		'@[[User:Example|Example]]:',
		replyTo{[2] = 'Example', label = 'Foo'}
	)
end

function suite:testNoFirstParamWithLabel2()
	self:assertContentEquals(
		'@[[User:Example|Foo]]:',
		replyTo{[2] = 'Example', label2 = 'Foo'}
	)
end

return suite