Module:ro-headword

local export = {}
local pos_functions = {}

local lang = require("Module:languages").getByCode("ro")

-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.show(frame)
	local args = frame:getParent().args
	NAMESPACE = mw.title.getCurrentTitle().nsText
	PAGENAME = mw.title.getCurrentTitle().text
	
	local poscat = frame.args or error("Part of speech has not been specified. Please pass parameter 1 to the module invocation.")
	
	local params = {
		 = {},
		 = {type = "boolean"},
		 = {list = true},
	}
	
	if pos_functions then
		for key, val in pairs(pos_functions.params) do
			params = val
		end
	end
	
	args = require("Module:parameters").process(args, params)
	
	local data = {lang = lang, pos_category = args and "suffixes" or poscat, categories = args and {"Romanian " .. poscat:sub(1, -2) .. "-forming suffixes"} or {}, heads = {args.head}, genders = {}, inflections = {}}
	local appendix = {}
	
	for key, val in ipairs(args.cat) do
		table.insert(data.categories, "Romanian " .. val)
	end
	
	if pos_functions then
		pos_functions.func(class, args, data, appendix)
	end
	
	if #appendix == 0 then
		appendix = ""
	end
	
	return
		require("Module:headword").full_headword(data) .. appendix
end

local function is_equal(a1, a2)
	if a1 == a2 then
		return true
	end
	
	if #a1 == #a2 then
		for i = 1, #a1 do
			if a1 ~= a2 then
				return false
			end
		end
		return true
	else
		return false
	end
end

pos_functions = {
	params = {
		 = {},
		 = {list = true, allow_holes = true},
		 = {list = true, allow_holes = true},
		 = {list = true, allow_holes = true},
		 = {list = true, allow_holes = true},
		 = {},
	},
	func = function(class, args, data, appendix)
		local mode = args
		local only = {}
		
		if args.only then
			for i, val in ipairs(mw.text.split(args.only, "-")) do
				only = true
			end
		end
		
		if mode == "inv" or mode == "i" or args.maxindex > 0 or args.maxindex > 0 or args.maxindex > 0 or args.maxindex > 0 then
			require("Module:debug").track("ro-adj new")
		end
		
		if mode == "inv" or mode == "ind" then
			table.insert(data.genders, "m")
			table.insert(data.genders, "f")
			table.insert(data.genders, "n")
			table.insert(data.inflections, {label = "indeclinable"})
			table.insert(data.categories, "Romanian indeclinable adjectives")
		else
			local form_order = {"m_sg", "f_sg", "m_pl", "f_pl"}
			local only_order = {"m", "f", "sg", "pl"}
			local allowed = {m_sg = true, f_sg = true, m_pl = true, f_pl = true}
			local only_names = {m = "masculine", f = "feminine", sg = "singular", pl = "plural"}
			
			for i, val in pairs(only_names) do
				if only then
					for key, form in pairs(allowed) do
						if not key:find(i) then
							allowed = false
						end
					end
				end
			end
			
			for i, val in ipairs(form_order) do
				if allowed then
					allowed = "lemma"
					break
				end
			end
		
			if allowed.m_sg == "lemma" then
				table.insert(data.genders, "m")
				
				if not only.m then
					table.insert(data.genders, "n")
				end
			elseif allowed.f_sg == "lemma" then
				table.insert(data.genders, "f")
			elseif allowed.m_pl == "lemma" then
				table.insert(data.genders, "m-p")
			elseif allowed.f_pl == "lemma" then
				table.insert(data.genders, "f-p")
				
				if not only.f then
					table.insert(data.genders, "n-p")
				end
			else
				error("All forms are excluded by the \"only\" parameter")
			end
			
			for i, val in ipairs(only_order) do
				if only then
					table.insert(data.inflections, {label = only_names .. " only"})
				end
			end
			
			local f, mp, fp = args, args.maxindex > 0 and args or args, args.maxindex > 0 and args or args
			
			require("Module:ro-adjective").make_basic_forms({PAGENAME}, f, mp, fp, mode == "i", only)
			
			local unified_sg, unified_pl = false, false
			
			if allowed.m_sg and allowed.f_sg and f.maxindex == 1 and f == PAGENAME then
				unified_sg = true
				table.insert(data.genders, 2, "f")
			end
		
			if not unified_sg and allowed.f_sg and allowed.f_sg ~= "lemma" then
				f.label = "feminine" .. (only.sg and "" or " singular")
				table.insert(data.inflections, f)
			end
			
			if allowed.m_pl and allowed.f_pl and is_equal(mp, fp) then
				unified_pl = true
				mp.label = "plural"
				table.insert(data.inflections, mp)
			end
			
			if not unified_pl and allowed.m_pl and allowed.m_pl ~= "lemma" then
				mp.label = (only.m and "" or "masculine") .. " " .. (only.pl and "" or "plural")
				table.insert(data.inflections, mp)
			end
				
			if not unified_pl and allowed.f_pl and allowed.f_pl ~= "lemma" then
				fp.label = (only.f and "" or "feminine and neuter") .. " " .. (only.pl and "" or "plural")
				table.insert(data.inflections, fp)
			end
		end
		
		return args
	end
}

pos_functions = pos_functions

pos_functions = pos_functions

pos_functions = pos_functions

pos_functions = {
	params = {
		 = {list = "g", default = "?"},
		 = {list = "pl"},
		 = {list = true},
		 = {list = true},
		 = {},
		 = {list = true, allow_holes = true},
		 = {list = true, allow_holes = true},
		 = {list = true, allow_holes = true},
		 = {}
	},
	func = function(class, args, data, appendix)
		local type
		
		for _, val in ipairs(args) do
			table.insert(data.genders, val)
			
			if val:match("p") then
				type = "plural"
				break
			end
		end
	
		if args then
			data.pos_category = "suffixes"
			table.insert(data.categories, "Romanian noun-forming suffixes")
			type = "suffix"
		end
		
		if type == "plural" then
			if args then
				args = {label = "normally plural"}
			else
				args = {label = "plural only"}
			end
			
			table.insert(data.categories, "Romanian pluralia tantum")
		else
			if args == "-" then
				args = {label = "]"}
				
				if type ~= "suffix" then
					table.insert(data.categories, "Romanian uncountable nouns")
				end
			elseif args == "!" then
				args = {}
				
				if type ~= "suffix" then
					table.insert(data.categories, "Romanian nouns with unattested forms")
				end
			else
				args.label = "plural"
				args.accel = {form = "indefinite|nominative//accusative|p"}
				
				if #args > 0 then
					for key, val in ipairs(args) do
						if ((val == "e" or val == "uri") and args == "n") or (val == "i" and args == "m") then
							args = PAGENAME .. val
						end
					end
					
					for key, val in ipairs(args) do
						if not mw.title.new(val).exists then
							table.insert(data.categories, "Romanian nouns with red links in their headword lines")
						end
								
						if args.pl_qual then
							args = {term = args, q = {args.pl_qual}}
						end
					end
					
					if type ~= "suffix" then
						table.insert(data.categories, "Romanian countable nouns")
					end
				else
					if type ~= "suffix" then
						args.request = true
					end
				end
			end
		end
	
		if args.label then
			table.insert(data.inflections, args)
		end
		
		if args then
			if type == "plural" then
				table.insert(data.inflections, {label = "singular", args})
			else
				error("Parameter \"sg\" can only be used for pluralia tantum")
			end
		end
		
		if #args > 0 then
			if args.f_qual.maxindex > 0 then
				for key, val in ipairs(args) do
					if args.f_qual then
						args = {term = args, q = {args.f_qual}}
					end
				end
			end
			
			args.label = "feminine equivalent"
			table.insert(data.inflections, args)
		end
		
		if #args > 0 then
			if args.m_qual.maxindex > 0 then
				for key, val in ipairs(args) do
					if args.m_qual then
						args = {term = args, q = {args.m_qual}}
					end
				end
			end
			
			args.label = "masculine equivalent"
			table.insert(data.inflections, args)
		end
		
		return args
	end
}

function format_conj(conj)
	if not conj then
		return ''
	else
		if conj == 1 then
			return '&nbsp;<i>]</i>'
		elseif conj == 2 then
			return '&nbsp;<i>]</i>'
		elseif conj == 3 then
			return '&nbsp;<i>]</i>'
		elseif conj == 4 then
			return '&nbsp;<i>]</i>'
		else
			return '&nbsp;<small></small>'
		end
	end
end

function get_conj(head, ind)
	local inf, conj = mw.ustring.match(require("Module:links").remove_links(head), '^a (.+)') or error('Head must begin with "a"')
	
	inf = mw.ustring.gsub(inf, 'á', 'a')
	inf = mw.ustring.gsub(inf, 'í', 'i')
	inf = mw.ustring.gsub(inf, '́', '')		-- remove combining acute
	
	if mw.ustring.match(inf, '$') then
		conj = 4
	elseif mw.ustring.match(inf, 'e$') then
		conj = 3
	elseif mw.ustring.match(inf, 'ea$') then
		if mw.ustring.match(inf, 'hea$') then
			conj = 1
		elseif ind then
			if mw.ustring.match(ind, 'ează$') then
				conj = 1
			else
				conj = 2
			end
		end
	elseif mw.ustring.match(inf, 'a$') then
		conj = 1
	else
		error('Unrecognized verb ending')
	end
	
	return conj
end

pos_functions = {
	params = {
		 = {list = "pres"},
		 = {list = "past"},
		 = {},
		 = {type = "number"},
		 = {list = "pres\1_qual", allow_holes = true},
		 = {list = "past\1_qual", allow_holes = true}
	},
	
	func = function(class, args, data, appendix)
		local multi = false
		
		if mw.ustring.match(PAGENAME, ' ') then
			multi = true
		end
		
		if #args > 0 and args.pres_qual.maxindex > 0 then
			for key, val in ipairs(args) do
				if args.pres_qual then
					args = {term = args, q = {args.pres_qual}}
				end
			end
		end
		
		if #args > 0 and args.past_qual.maxindex > 0 then
			for key, val in ipairs(args) do
				if args.past_qual then
					args = {term = args, q = {args.past_qual}}
				end
			end
		end
		
		if args == "!" then
			table.insert(data.inflections, {label = "third-person singular present not attested"})
			table.insert(data.categories, 'Romanian verbs with unattested forms')
		elseif args == "-" then
			table.insert(data.inflections, {label = "third-person singular present not used"})
			table.insert(data.categories, "Romanian defective verbs")
		else
			args.label = 'third-person singular present'
			args.request = true
			table.insert(data.inflections, args)
		end
		
		if args == "!" then
			table.insert(data.inflections, {label = "past participle not attested"})
			table.insert(data.categories, 'Romanian verbs with unattested forms')
		elseif args == "-" then
			table.insert(data.inflections, {label = "past participle not used"})
			table.insert(data.categories, "Romanian defective verbs")
		else
			args.label = 'past participle'
			args.request = true
			table.insert(data.inflections, args)
		end
		
		local sc = lang:findBestScript(data.heads or args.inf or PAGENAME):getCode()
		
		if not data.heads then
			if not args.inf then
				if multi then
					args.inf = mw.text.split(PAGENAME, ' ')
					args.inf = '] ]'
				else
					args.inf = PAGENAME
				end
			end
			
			if sc == 'Cyrl' then
				data.heads = {'а ' .. args.inf} --Cyrillic 'а'
			else
				data.heads = {'a ' .. args.inf}
			end
		end
	
		local conj
		
		if multi or NAMESPACE ~= '' or sc == 'Cyrl' then
			conj = args.conj or 0
		else
			conj = get_conj(data.heads, args)
			
			if args.conj and args.conj ~= conj then
				require("Module:debug").track('ro-verb with wrong conjugation')
			end
		end
	
		if conj then
			if conj == 1 then
				table.insert(data.categories, 'Romanian verbs in 1st conjugation')
			elseif conj == 2 then
				table.insert(data.categories, 'Romanian verbs in 2nd conjugation')
			elseif conj == 3 then
				table.insert(data.categories, 'Romanian verbs in 3rd conjugation')
			elseif conj == 4 then
				table.insert(data.categories, 'Romanian verbs in 4th conjugation')
			else
				table.insert(data.categories, 'Requests for inflections in Romanian entries')
			end
		end
	
		appendix = format_conj(conj)
	end
}

return export