Modül:he-başlıkbaşı

local m_baslikbasi = require("Modül:başlık başı")
local com = require("Modül:he-genel")

local export = {}
local pos_functions = {}

local lang = require("Modül:diller").getirKodaGore("he")

local function get_params_list(args, argprefix)
	local export = {}
	i = 1
	term = argprefix

	while args ~= nil and args ~= "" do
		table.insert(export, term)

		i = i + 1
		term = argprefix .. i
	end
	return export
end

local function make_params_array(args, params)
	local export = {}
	for _, param in ipairs(params) do
		table.insert(export, args)
	end
	return export
end

local function maybe_get_inflection(args, name, params, list, accel, is_construct)
	if list then
		params = get_params_list(args, params)
	end
	
	local tbl = {}
	if type(params) ~= "table" then
		params = {params}
	end
	for _, param in ipairs(params) do
		local paramwv = param .. "wv"
		local paramdwv = param .. "dwv"
		if args or args or args then
			tbl.label = name
			tbl.accel = accel
			if is_construct == true then
				table.insert(tbl, com.gen_link_ending_with_makaf(args, args, args))
			else
				table.insert(tbl, com.gen_link(args, args, args))
			end
		end
		if args == "" or args == "" or args == "" then
		elseif args ~= nil and args ~= nil then
		end
	end
	return next(tbl) and tbl
end

-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.goster(frame)
	local args = {}
	for k, v in pairs(frame:getParent().args) do
		if v ~= "" then
			args = v
		end
	end
	local poscat = frame.args or error("Part of speech has not been specified. Please pass parameter 1 to the module invocation.")
	
	if frame.args and (args == "" or not args) then args = frame.args end
	
	local veri = {dil = lang, soz_kategorisi = poscat, kategoriler = {}, baslar = make_params_array(args, get_params_list(args, "head")), alfabecevler = make_params_array(args, get_params_list(args, "tr")), cinsiyetler = {}, cekimler = {}}
	local head = args; if head == "" then head = nil end; veri.baslar = head
	
	veri.sira_anahtari = args; if veri.sira_anahtari == "" then veri.sira_anahtari = nil end
	
	if veri.sira_anahtari then
		veri.sira_anahtari = veri.sira_anahtari .. "a" .. mw.title.getCurrentTitle().subpageText
	end
	
	local wv = args or mw.title.getCurrentTitle().subpageText
	local dwv = args
	
	if not veri.baslar then
		if dwv then
			veri.baslar = wv .. " \\ " .. '<span class="inflection-table">' .. "]" .. "</span>" -- not really an inflection table but for the black links
		else
			veri.baslar = wv
		end
	end
	
	if dwv and mw.ustring.match(dwv, "%[%[") then
	end
	
	if not (args or args or args) then
	end
	
	if mw.ustring.match(wv, "׳") then
		table.insert(veri.kategoriler, "İbranice terms spelled with geresh")
	end
	
	if mw.ustring.match(wv, "״") then
		table.insert(veri.kategoriler, "İbranice terms spelled with gershayim")
	end

	local begedkefet = "בגדכפת"
	local vowels = "ְֱֲֳִֵֶַָֹֻ"
	local dagesh = "ּֿ"
	local begedkefet_regex = ""
	local vowels_regex = ""
	local dagesh_regex = ""

	if args == "1" or mw.ustring.match(com.fix_nikud(dwv or wv), "^" .. begedkefet_regex .. vowels_regex) then
		table.insert(veri.kategoriler, "İbranice terms beginning with an unchangeable begedkefet letter")
	elseif mw.ustring.match(com.fix_nikud(dwv or wv), "^" .. begedkefet_regex .. dagesh_regex) then
		table.insert(veri.kategoriler, "İbranice terms beginning with a begedkefet letter")
	end

	local pattern_link = ""
	if args and args ~= "" and poscat ~= "verbs" then
		table.insert(veri.kategoriler, "İbranice terms in the pattern " .. args)
		local patfmt = require("Modül:bağlantılar").tam_bag({dil = lang, alt = args, c = "-"})
		pattern_link = " <small> .. "| ]]</small>"
	end

	if pos_functions then
		pos_functions(args, veri, wv)
	end

	table.insert(veri.cekimler, maybe_get_inflection(args, "Biblical Hebrew ]", "pausal", false))
	
	return (m_baslikbasi.tam_baslikbasi(veri)) .. pattern_link
end

local final_to_nonfinal = {
	="כ",
	="מ",
	="נ",
	="פ",
	="צ",
}

local function stemify_helper(letter, rest)
	return (final_to_nonfinal or letter) .. rest
end

local function stemify(x)
	if x then
		x = mw.ustring.gsub(x, "ְ(*)$", "%1")
		x = mw.ustring.gsub(x, "()(*)$", stemify_helper)
	end
	return x
end

local function gen_fem_t(stemwv)
	local stub, vowel, final, dagesh = mw.ustring.match(com.fix_nikud(stemwv), "^(.*)()(?)(ּ?)$")
	if not stub then
		error("Error attaching feminine ת suffix, please check vocalization.")
	end
	if final == "י" then
		if vowel ~= "ִ" or dagesh ~= "ּ" then
			error("Error attaching feminine ת suffix, please check vocalization.")
		end
		return stub .. vowel .. final .. "ת"
	end
	if vowel == "ִ" or dagesh ~= "" then
		error("Error attaching feminine ת suffix, please check vocalization.")
	end
	if final == "א" then
		return stub .. "ֵ" .. final .. "ת"
	end
	if final == "ה" or final == "ח" or final == "ע" then
		return stub .. "ַ" .. final .. "ַ" .. "ת"
	end
	return stub .. "ֶ" .. final .. "ֶ" .. "ת"
end

pos_functions = function(args, veri)
	-- table.insert(genders, "m")
	if args == nil or args == "" then
		-- Use only provided inflections
		table.insert(veri.cekimler, maybe_get_inflection(args, "feminine", {"f", "f2"}, false))
		table.insert(veri.cekimler, maybe_get_inflection(args, "masculine plural", {"mp", "mp2"}, false))
		table.insert(veri.cekimler, maybe_get_inflection(args, "feminine plural", "fp", true))
	else
		-- Automatically generate inflections
		local stem = args
		local stemwv = args
		local stemdwv = args
		local e = false
		if not stem then
			if stemwv then
				stem = com.remove_nikud(stemwv)
			else
				stem = stemify(mw.title.getCurrentTitle().subpageText)
				if not stemdwv then
					stemwv = stemify(args)
					stemdwv = stemify(args)
				end
				local fstemwv = stemwv and com.fix_nikud(stemwv)
				local fstemdwv = stemdwv and com.fix_nikud(stemdwv)
				if (fstemwv or fstemdwv) and (stem ~= nil or stem:match("ה$")) and (fstemwv == nil or fstemwv:match("ֶה$")) and (fstemdwv == nil or fstemdwv:match("ֶה$")) then
					e = true
					stem = stem and stem:gsub("ה$", "")
					stemwv = fstemwv and fstemwv:gsub("ֶה$", "")
					stemdwv = fstemdwv and fstemdwv:gsub("ֶה$", "")
				end
			end
		end
		stem, stemwv, stemdwv = com.process_wv_triad(stem, stemwv, stemdwv)
		local f, fwv, fdwv = com.process_wv_triad(args, args, args)
		local f2, f2wv, f2dwv = com.process_wv_triad(args, args, args)
		local mp, mpwv, mpdwv = com.process_wv_triad(args, args, args)
		local mp2, mp2wv, mp2dwv = com.process_wv_triad(args, args, args)
		local fp, fpwv, fpdwv = com.process_wv_triad(args, args, args)
		if f ~= "-" then
			if not (f or fwv or fdwv) then
				f = stem and (stem .. "ה")
				fwv = stemwv and (stemwv .. "ָה")
				fdwv = stemdwv and (stemdwv .. "ָה")
			elseif f == "ת" and not (fwv or fdwv) then
				f = stem and (stem .. (e and "ית" or "ת"))
				fwv = stemwv and (e and (stemwv .. "ֵית") or gen_fem_t(stemwv))
				fdwv = stemdwv and (e and (stemdwv .. "ֵית") or gen_fem_t(stemdwv))
			end
			if f2 == "ת" and not (f2wv or f2dwv) then
				f2 = stem and (stem .. (e and "ית" or "ת"))
				f2wv = stemwv and (e and (stemwv .. "ֵית") or gen_fem_t(stemwv))
				f2dwv = stemdwv and (e and (stemdwv .. "ֵית") or gen_fem_t(stemdwv))
			end
			tbl = {label = "feminine", com.gen_link(f, fwv, fdwv)}
			if f2 or f2wv or f2dwv then
				table.insert(tbl, com.gen_link(f2, f2wv, f2dwv))
			end
			table.insert(veri.cekimler, tbl)
		end
		if mp ~= "-" then
			if not (mp or mpwv or mpdwv) then
				mp = stem and (stem .. "ים")
				mpwv = stemwv and (stemwv .. "ִים")
				mpdwv = stemdwv and (stemdwv .. "ִים")
			end
			tbl = {label = "masculine plural", com.gen_link(mp, mpwv, mpdwv)}
			if mp2 or mp2wv or mp2dwv then
				table.insert(tbl, com.gen_link(mp2, mp2wv, mp2dwv))
			end
			table.insert(veri.cekimler, tbl)
		end
		if fp ~= "-" then
			if not (fp or fpwv or fpdwv) then
				fp = stem and (stem .. "ות")
				fpwv = stemwv and (stemwv .. "וֹת")
				fpdwv = stemdwv and (stemdwv .. "וֹת")
			end
			tbl = {label = "feminine plural", com.gen_link(fp, fpwv, fpdwv)}
			table.insert(veri.cekimler, tbl)
		end
	end
end

pos_functions = function(args, veri, wv)
	if args == "m" or args == "m-p" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cekimler, maybe_get_inflection(args, "feminine counterpart", "f", true))
	elseif args == "f" or args == "f-p" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cekimler, maybe_get_inflection(args, "masculine counterpart", "m", false))
	end
end

pos_functions = function(args, veri, wv)
	local origin = " origin-" .. wv:gsub("%%", "."):gsub(" ", "_")

	if args == "m" or args == "f" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		if args ~= nil then
		end
	elseif args == "m-d" or args == "f-d" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.kategoriler, "İbranice dualia tantum")
		table.insert(veri.cekimler, maybe_get_inflection(args, "singular indefinite", "sg", false))
	elseif args == "m-p" or args == "f-p" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.kategoriler, "İbranice topluluk adları")
		table.insert(veri.cekimler, maybe_get_inflection(args, "singular indefinite", "sg", false))
	elseif args == "" or args == nil then
		table.insert(veri.cinsiyetler, "?")
		table.insert(veri.kategoriler, "İbranice cinsiyeti eksik sözcükler")
	end
	
	-- Dual forms rare enough that there's no need for without/missing categoristion
	table.insert(veri.cekimler, maybe_get_inflection(args, "dual indefinite", "dual", true))

	if args == "-" then
		table.insert(veri.cekimler, {label = "no plural forms"})
		table.insert(veri.kategoriler, "İbranice nouns without plural forms")
	elseif args == "" or args == nil then
		table.insert(veri.kategoriler, "İbranice noun entries missing plural forms")
	else
		table.insert(veri.cekimler, maybe_get_inflection(args, "plural indefinite", "pl", true, "plural-form-of" .. origin))
		if args == "m" and mw.ustring.sub(com.remove_nikud(args), -2, -1) == "ות" then
			table.insert(veri.kategoriler, "İbranice masculine nouns with plurals ending in ־ות")
		elseif args == "f" and mw.ustring.sub(com.remove_nikud(args), -2, -1) == "ים" then
			table.insert(veri.kategoriler, "İbranice feminine nouns with plurals ending in ־ים")
		end
		if mw.ustring.sub(com.remove_nikud(args), -3, -1) == "יים"
		and mw.ustring.sub(mw.ustring.gsub(com.remove_nikud(wv), "]", ""), -1, -1) ~= "י" then
			table.insert(veri.kategoriler, "İbranice nouns with plurals ending in ־יים")
		end
	end

	if args == "-" then
		table.insert(veri.cekimler, {label = "no construct forms"})
		table.insert(veri.kategoriler, "İbranice nouns without construct forms")
	else
		if args == "" or args == nil then
			table.insert(veri.kategoriler, "İbranice noun entries missing singular construct forms")
		else
			table.insert(veri.cekimler, maybe_get_inflection(args, "singular construct", "cons", true, "construct-form-of" .. origin, true))
		end
		table.insert(veri.cekimler, maybe_get_inflection(args, "dual construct", "dualcons", true , nil, true))
		if (args == "" or args == nil) and args ~= "-" then
			table.insert(veri.kategoriler, "İbranice noun entries missing plural construct forms")
		else
			table.insert(veri.cekimler, maybe_get_inflection(args, "plural construct", "plcons", true, "plural-construct-form-of" .. origin, true))
		end
	end

	table.insert(veri.cekimler, maybe_get_inflection(args, "masculine counterpart", "m", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "feminine counterpart", "f", true))

	if args == "m" and mw.ustring.sub((com.remove_nikud(args or args or mw.title.getCurrentTitle().subpageText)), -1) == "ת" then
		table.insert(veri.kategoriler, "İbranice masculine nouns ending in ־ת")
	elseif args == "m" and mw.ustring.sub((com.remove_nikud(args or args or mw.title.getCurrentTitle().subpageText)), -1) == "ה" then
		table.insert(veri.kategoriler, "İbranice masculine nouns ending in ־ה")
	end
end

pos_functions = function(args, veri)
	table.insert(veri.cekimler, maybe_get_inflection(args, "construct", "cons", true, nil, true))
	
	table.insert(veri.cekimler, maybe_get_inflection(args, "dual", "dual", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "plural", "pl", true))
	local f = maybe_get_inflection(args, "feminine", "f", true)
	table.insert(veri.cekimler, f)
	table.insert(veri.cekimler, maybe_get_inflection(args, "feminine construct", "fcons", true, nil, true))

	table.insert(veri.cinsiyetler, "m")
	if not f then
		table.insert(veri.cinsiyetler, "f")
	end
end

pos_functions = function(args, veri)
	if args == "m" or args == "f" or args == "m-p" or args == "f-p" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
	elseif args then
	end
end

pos_functions = function(args, veri, wv)
	local origin = " origin-" .. wv:gsub("%%", "."):gsub(" ", "_")

	if args and args ~= "-" and args ~= "" then
		table.insert(veri.cekimler, maybe_get_inflection(args, "plural indefinite", "pl", true, "plural-form-of" .. origin))
		if args == "m" and mw.ustring.sub(com.remove_nikud(args), -2, -1) == "ות" then
			table.insert(veri.kategoriler, "İbranice masculine nouns with plurals ending in ־ות")
		elseif args == "f" and mw.ustring.sub(com.remove_nikud(args), -2, -1) == "ים" then
			table.insert(veri.kategoriler, "İbranice feminine nouns with plurals ending in ־ים")
		end
		if mw.ustring.sub(com.remove_nikud(args), -3, -1) == "יים"
		and mw.ustring.sub(mw.ustring.gsub(com.remove_nikud(wv), "]", ""), -1, -1) ~= "י" then
			table.insert(veri.kategoriler, "İbranice nouns with plurals ending in ־יים")
		end
	end

	if args == "m" or args == "f" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
	elseif args == "m-d" or args == "f-d" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.kategoriler, "İbranice dualia tantum")
	elseif args == "m-p" or args == "f-p" then
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.cinsiyetler, args)
		table.insert(veri.kategoriler, "İbranice topluluk adları")
	elseif args == "" or args == nil then
		table.insert(veri.kategoriler, "İbranice cinsiyeti eksik özel adlar")
	elseif args == "-" then --surnames don't really have gender
		table.insert(veri.kategoriler, "İbranice cinsiyetsiz özel adlar")
	else
		table.insert(veri.cinsiyetler, "?")
	end
end

local binyanim = {
	 = "pa'al",
	 = "pi'el",
	 = "hif'il",
	 = "hitpa'el",
	 = "huf'al",
	 = "pu'al",
	 = "nif'al",
	 = "hitpu'al", -- should this be included?
}

local weakroots = {
	 = {
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
	},
	 = {
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
	},
	 = {
		 = true,
		 = true,
		 = true,
		 = true,
		 = true,
	},
}

local function maybe_get_weakcat(args, pos, binyan)
	if weakroots] then
		if binyan then
			return "İbranice " .. pos .. "״" .. args .. " " .. binyan .. " verbs"
		else
			return "İbranice " .. pos .. "״" .. args .. " verbs"
		end
	else
		return nil -- perhaps track error if args ~= ""
	end
end

pos_functions = function(args, veri)
	local binyan = binyanim]
	if binyan then
		table.insert(veri.cekimler, { label="]" })
		table.insert(veri.kategoriler, "İbranice " .. binyanim] .. " verbs")
	elseif args ~= "-" then
		table.insert(veri.kategoriler, "İbranice verbs lacking binyan")
	end
	table.insert(veri.kategoriler, maybe_get_weakcat(args, "פ", binyan))
	table.insert(veri.kategoriler, maybe_get_weakcat(args, "ע", binyan))
	table.insert(veri.kategoriler, maybe_get_weakcat(args, "ל", binyan))
	table.insert(veri.cekimler, maybe_get_inflection(args, "infinitive", "inf", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "present", "pres", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "future", "fut", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "imperative", "imp", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "passive participle", "passp", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "passive counterpart", "pass", true))
	table.insert(veri.cekimler, maybe_get_inflection(args, "active counterpart", "act", true))
end

return export