Module:columns/old

local export = {}

local m_links = require("Module:links")
local m_languages = require("Module:languages")


-- Custom functions for generating a sortkey that will achieve the desired sort
-- order.
-- name of module and name of exported function
local custom_sort_functions = {
	egy = { "egy-utilities", "make_sortkey" },
	zh = { "Hani-sortkey", "makeSortKey" },
}


local function get_col_lengths(n_columns, n_items)
	local r = math.mod(n_items, n_columns)
	local col_lengths = {}
	
	for i = 1, n_columns do
		table.insert(col_lengths, (n_items - r) / n_columns)
		if (i <= r) then
			col_lengths = col_lengths + 1
		end
	end
	
	return col_lengths
end


local function set_columns(n_columns, items, line_start, lang)
	local col_lengths = get_col_lengths(n_columns, #items)
	local result = {}
	local count = 1
	
	for i = 1, n_columns do
		local col = {}
		for j = 1, col_lengths do
			local item = items
			
			if lang and not string.find(item, "<span") then
				item = m_links.full_link({lang = lang, term = item})
			end
			
			table.insert(col, "\n")
			table.insert(col, line_start)
			table.insert(col, item)
			
			count = count + 1
		end
		result = table.concat(col)
	end
	
	return result
end


-- Compares bytes, which always yields the same result as comparing code points
-- in valid UTF-8 strings.
local laborious_comp
do
	local byte, min = string.byte, math.min
	laborious_comp = function (item1, item2)
		local l1, l2 = #item1, #item2
		for i = 1, min(l1, l2) do
			local char1, char2 = byte(item1, i, i), byte(item2, i, i)
			if char1 ~= char2 then
				return char1 < char2
			end
		end
		return l1 < l2
	end
end


-- Returns true if table contains strings that can be compared with < (less than).
-- This requires that they do not have code points above U+FFFF. The C locale
-- used by our copy of Lua does not handle them correctly. These code points
-- are encoded by byte sequences four bytes long that begin with the bytes 240
-- to 244 (0xF0 to 0xF4).
local function contains_safely_comparable_strings(strings)
	for _, str in ipairs(strings) do
		if str:find '' then
			return false
		end
	end
	return true
end


local function do_alphabetize(content, lang)
	local safely_comparable = contains_safely_comparable_strings(content)
	if safely_comparable then
		-- This is actually tracking presence of characters outside of the
		-- ] (BMP), many of which are in the
		-- ] (SMP).
		--]
		require 'Module:debug'.track('columns/SMP')
	end
	
	if lang then
		local cache = {}
		
		local custom_sort_function = custom_sort_functions
		local makeSortKey =
			custom_sort_function and require("Module:" .. custom_sort_function)]
			or function(text)
			return (lang:makeSortKey(text))
		end
		local function prepare(element)
			local result = cache
			
			if result then
				return result
			end
			
			result = m_links.remove_links(element)
			result = mw.ustring.gsub(result, "", "")
			result = makeSortKey((lang:makeEntryName(result)))
			cache = result
			
			return result
		end
		
		local comp = not safely_comparable and function(item1, item2)
				return laborious_comp(prepare(item1), prepare(item2))
			end
			or function (item1, item2)
				return prepare(item1) < prepare(item2)
			end
		
		table.sort(content, comp)
	else
		table.sort(content, not safely_comparable and laborious_comp or nil)
	end
end


local function get_col_header(bg, collapse, class, title, column_width)
	if collapse then
		return table.concat {'<div class="NavFrame">\n<div class="NavHead">',
						title,
						'</div>\n<div class="NavContent">\n{| style="width: 100%;" role="presentation" class="',
						class,
						'"\n|-\n| style="vertical-align: top; text-align: left; background-color: ',
						bg,
						'; color: inherit; width: ',
						column_width,
						'%;" |'}
	else
		return table.concat {'<div style="width: auto; margin: 0; overflow: auto;">\n{| role="presentation" style="width: 100%"\n|-\n| style="background: ',
						bg,
						'; color: inherit; vertical-align: top; width: ',
						column_width,
						'%" |'}
	end

end


function export.create_table(n_columns, content, alphabetize, bg, collapse, class, title, column_width, line_start, lang)
	if column_width then
		require("Module:debug").track("columns/column_width")
	end
	
	column_width = column_width or math.floor(80 / n_columns)
	
	if line_start then
		require("Module:debug").track("columns/line_start")
	end
	
	line_start = line_start or "* "
	
	local separator = '\n| style="width: 1%;" |\n| style="background: ' .. bg .. '; color: inherit; vertical-align: top; text-align: left; width: ' .. column_width .. '%;" |'
	local final = ''
	if collapse then
		final = '\n|}</div></div>'
	else
		final = '\n|}</div>'
	end
	
	if alphabetize then
		do_alphabetize(content, lang)
	end
	
	local header = get_col_header(bg, collapse, class, title, column_width)
	local output = set_columns(n_columns, content, line_start, lang)
	
	-- Add separator between each column.
	for i = 2, (#output - 1) * 2, 2 do
		table.insert(output, i, separator)
	end
	
	table.insert(output, 1, header)
	table.insert(output, final)
	
	return table.concat(output)
end


function export.display(frame)
	local params = {
		 = {default = "derivedterms"},
		 = {type = "boolean"},
		 = {type = "number", default = 1},
		 = {},
		 = {type = "boolean"},
		 = {default = ""},
	}
	
	local frame_args = require("Module:parameters").process(frame.args, params)
	
	params = {
		 = {list = true},
		
		 = {},
		 = not frame_args and {required = true, default = "und"} or nil,
		 = {},
	}
	
	local args = require("Module:parameters").process(frame:getParent().args, params)
	
	local lang = frame_args or args
	lang = m_languages.getByCode(lang) or m_languages.err(lang, "lang")
	
	return export.create_table(frame_args, args, frame_args, "#F8F8FF", frame_args, frame_args, args or frame_args, nil, nil, lang)
end


return export