Module:HonorUtils

Documentation for this module may be created at Module:HonorUtils/doc

local p = {}
local utilities = require ( "Module:Utilities" )
local notUseLUAPattern = true

function p.getExpandedHonorVariantsV2( frame, landingPage )
	if ( landingPage == nil or landingPage == "" ) then
		landingPage = frame:expandTemplate{ title='GetHonorLandingPage' }
	end
	local parentFrame = frame:getParent()
	mw.log('HonorUtils.getExpandedHonorVariantsV2 (parentFrame:getTitle): '..parentFrame:getTitle())
	local srcIsHonor = false
	
	-- see if template has variants as arguments
	local tAnswerVariants = getHonorVariants( 'answerKey', landingPage, srcIsHonor )
	if ( tAnswerVariants == nil ) then
		local cnt_answerKey_variants = parentFrame.args['cnt_answerKey_variants']
		if ( cnt_answerKey_variants ~= nil and cnt_answerKey_variants ~= '' ) then
			tAnswerVariants = {}
			-- get answer Variants
			mw.log('HonorTabs.generateHonorTabs (cnt_answerKey_variants): '..cnt_answerKey_variants)
			for actVariant = 1, tonumber(cnt_answerKey_variants), 1 do
				mw.log('HonorTabs.generateHonorTabs (actVariant) answerkey: '..actVariant)
				strActVariant = 'answerKey_' .. actVariant
				tAnswerVariants[actVariant] = parentFrame.args[strActVariant]
				mw.log('HonorTabs.generateHonorTabs (tAnswerVariants[actVariant]): '..tAnswerVariants[actVariant])
			end
		end
	end
	
	local tRequirementVariants = getHonorVariants( 'requirements', landingPage, srcIsHonor )
	if ( tRequirementVariants == nil ) then
		local cnt_requirements_variants = parentFrame.args['cnt_requirements_variants']
		if ( cnt_requirements_variants ~= nil and cnt_requirements_variants ~= ''  ) then
			tRequirementVariants = {}
			-- get requirement Variants
			mw.log('HonorTabs.generateHonorTabs (cnt_answerKey_variants): '..cnt_requirements_variants)
			for actVariant = 1, tonumber(cnt_requirements_variants), 1 do
				mw.log('HonorTabs.generateHonorTabs (actVariant) requirements: '..actVariant)
				strActVariant = 'requirements_' .. actVariant
				tRequirementVariants[actVariant] = parentFrame.args[strActVariant]
				mw.log('HonorTabs.generateHonorTabs (tRequirementVariants[actVariant]): '..tRequirementVariants[actVariant])
			end
		end
	end
	local tVariants = {
		answers = tAnswerVariants,
		requirements = tRequirementVariants
	}
	
	tVariants = p.expandHonorVariantsV2( frame, tVariants )
	
	tVariants = p.translateHonorVariantsV2( frame, tVariants )
	return tVariants
end

function p.expandHonorVariantsV2( frame, tVariants )
	local tRetVariants = tVariants
	if ( tVariants == nil ) then
		mw.log('HonorUtils.expandHonorVariantsV2: No Variants to Expand (nil)!')
		return {}
	end
	if ( tVariants['answers'] == nil ) then
		mw.log('HonorUtils.expandHonorVariantsV2: No Answer Variants to Expand!')
	else
		-- expand the answer Variants
		local tAnswers = tVariants['answers']
		mw.log('HonorUtils.expandHonorVariantsV2: There are '..#tAnswers..' Answer Variants to Expand!')
		for key, variant in pairs(tAnswers) do
			mw.log('HonorUtils.expandHonorVariantsV2 (key, variant): '..key..', '..variant)
			-- seperate Countries and Authority
			local tSplitAnsVariant = mw.text.split(variant, ';;', notUseLUAPattern)
			local tActVariant = {
				orig = variant,
				countries = {}
			}
			if ( tSplitAnsVariant[1] ~= '') then
				tActVariant['countries']['orig'] = tSplitAnsVariant[1]
				-- seperate the Countries
				tActVariant['countries']['split'] = mw.text.split(tActVariant['countries']['orig'], ';', notUseLUAPattern)
				mw.log('HonorUtils.expandHonorVariantsV2 (Countries - Orig): '..tActVariant['countries']['orig'])
			else
				mw.log('HonorUtils.expandHonorVariantsV2: There are no countries for that variant!')
			end
			-- set the authority
			if ( tSplitAnsVariant[2] == nil ) then
				tActVariant['authority'] = nil
				mw.log('HonorUtils.expandHonorVariantsV2 (Authority): nil')
			else
				tActVariant['authority'] = tSplitAnsVariant[2]
				mw.log('HonorUtils.expandHonorVariantsV2 (Authority): '..tActVariant['authority'])
			end
			-- save act. Variant into the table
			tAnswers[key] = tActVariant
		end
		tVariants['answers'] = tAnswers
		mw.log('HonorUtils.expandHonorVariantsV2: '..#tVariants['answers']..' Answer Variants expanded!')
	end
	if ( tVariants['requirements'] == nil ) then
		mw.log('HonorUtils.expandHonorVariantsV2: No Requirement Variants to Expand!')
	else
		-- expand the requirement Variants
		local tRequirements = tVariants['requirements']
		mw.log('HonorUtils.expandHonorVariantsV2: There are '..#tRequirements..' Requirement Variants to Expand!')
		for key, variant in pairs(tRequirements) do
			mw.log('HonorUtils.expandHonorVariantsV2 (key, variant): '..key..', '..variant)
			-- seperate Authorities
			local tSplitReqVariant = mw.text.split(variant, ';', notUseLUAPattern)
			local tActReqVariant = {
				orig = variant,
				authorities = tSplitReqVariant
			}
			tRequirements[key] = tActReqVariant
		end
		tVariants['requirements'] = tRequirements
		mw.log('HonorUtils.expandHonorVariantsV2: '..#tVariants['requirements']..' Requirement Variants expanded!')
	end
	return tRetVariants
end

function p.getExpandedHonorVariants(frame, variantsString, landingPage, targetPage)
	-- check the input variables
	if (frame == nil or landingPage == nil or landingPage == "" or targetPage == nil or targetPage == "") then
		return "fatal error"
	end
	if (variantsString == nil or variantsString == "") then
		local linkTitle = utilities.localize( targetPage )
		-- check if Localization returned something, if not set the original string
		if ( linkTitle == '') then
			linkTitle = targetPage
		end
		return {
			{
				url = "[[" .. landingPage .. "/" .. targetPage .. frame:expandTemplate{title='GetLangSuffix'} .. "|" .. linkTitle .. "]]"
			}
		}
	end
	
	local t_variants = p.expandHonorVariants(frame, variantsString)
	t_variants = p.translateHonorVariants(frame, t_variants)
	t_variants = p.createHonorVariantsURLs(frame, t_variants, landingPage, targetPage)
	return t_variants
end

function p.expandHonorVariants(frame, variantsString)
	if (variantsString == nil or variantsString == "") then return {} end
	
	local t_variants = mw.text.split( variantsString, ';;', notUseLUAPattern )
	
	for key, variant in pairs(t_variants) do
		t_variants[key] = {
			orig = variant,
			countries = mw.text.split( variant, ';', notUseLUAPattern )
		}
	end
	
	return t_variants
end

function p.translateHonorVariantsV2( frame, tVariants )
	local tRetVariants = tVariants
	if ( tRetVariants == nil ) then
		mw.log('HonorUtils.translateHonorVariantsV2: There are no Variants (nil)!')
	end
	if ( tRetVariants['answers'] == nil ) then
		mw.log('HonorUtils.translateHonorVariantsV2: There are no Answer Variants!')
	else
		mw.log('HonorUtils.translateHonorVariantsV2: There are '..#tRetVariants['answers']..' Answer Variants to translate!')
		for varKey, variant in pairs(tRetVariants['answers']) do
			if ( variant == nil or variant['countries'] == nil or variant['countries']['split'] == nil ) then
				mw.log('HonorUtils.translateHonorVariantsV2: Answer Variant is invalid!')
			else
				mw.log('HonorUtils.translateHonorVariantsV2: There are '..#variant['countries']['split']..' Answer Variant Countries to translate!')
				for countryKey, country in pairs(variant['countries']['split']) do
					local trans = utilities.localize( country, 'Countries' )
					-- check if Localization returned something, if not set the original string
					mw.log('HonorUtils.translateHonorVariantsV2 (country, trans): '..country..', '..trans)
					if ( trans == '' ) then
						trans = country
					end
					tRetVariants['answers'][varKey]['countries']['split'][countryKey] = {
						orig = country,
						translated = trans
					}
				end
				mw.log('HonorUtils.translateHonorVariantsV2: '..#tRetVariants['answers'][varKey]['countries']['split']..' Answer Variant Countries were translated!')
			end
		end
		mw.log('HonorUtils.translateHonorVariantsV2: '..#tRetVariants['answers']..' Answer Variants were translated!')
	end
	if ( tRetVariants['requirements'] == nil ) then
		mw.log('HonorUtils.translateHonorVariantsV2: There are no Requirement Variants!')
	else
		mw.log('HonorUtils.translateHonorVariantsV2: There are '..#tRetVariants['requirements']..' Requriement Variants to translate!')
		for varKey, variant in pairs(tRetVariants['requirements']) do
			if ( variant == nil or variant['authorities'] == nil ) then
				mw.log('HonorUtils.translateHonorVariantsV2: Requriement Variant is invalid!')
			else
				mw.log('HonorUtils.translateHonorVariantsV2: There are '..#variant['authorities']..' Requriement Variant Authorities to translate!')
				for authorityKey, authority in pairs(variant['authorities']) do
					local trans = utilities.localize( authority, 'Authorities' )
					-- check if Localization returned something, if not set the original string
					if ( trans == '' ) then
						trans = authority
					end
					tRetVariants['requirements'][varKey]['authorities'][authorityKey] = {
						orig = authority,
						translated = trans
					}
				end
				mw.log('HonorUtils.translateHonorVariantsV2: '..#tRetVariants['requirements'][varKey]['authorities']..' Requriement Variant Authorities were translated!')
			end
		end
		mw.log('HonorUtils.translateHonorVariantsV2: '..#tRetVariants['requirements']..' Requriement Variants were translated!')
	end
	return tRetVariants
end

function p.translateHonorVariants(frame, variants)
	local ret_t_variants = variants
	for varKey, variant in pairs(variants) do
		for countryKey, country in pairs(variant['countries']) do
			local trans = utilities.localize( country, 'Countries' )
			-- check if Localization returned something, if not set the original string
			if ( trans == '' ) then
				trans = country
			end
			local t_countryTrans = {
				orig = country,
				translation = trans
			}
			ret_t_variants[varKey]['countries'][countryKey] = t_countryTrans
		end
	end
	return ret_t_variants
end

function p.createHonorVariantsURLs(frame, variants, landingPage, targetPage)
	local t_variants = variants
	local langSuffix = frame:expandTemplate{title='GetLangSuffix'}
	for key, variant in pairs(variants) do
		local linkTitle = ""
		for countryKey, country in pairs(variant['countries']) do
			if (#linkTitle > 0) then
				linkTitle = linkTitle .. " & " .. country['translation']
			else
				linkTitle = country['translation']
			end
		end
		t_variants[key]['url'] ="[[" .. landingPage .. "_(" .. variant['orig'] .. ")/" .. targetPage .. langSuffix .. "|" .. linkTitle .. "]]"
	end
	return t_variants
end

function getHonorVariants(variantType, src, srcIsHonor)
	if (variantType == nil or variantType == '') then
		variantType = 'requirement'
	end
	local cntOfVariants = tonumber(p.getHonorMetadata(src, 'cnt_'..variantType..'_variants', srcIsHonor))
	if (cntOfVariants == nil or cntOfVariants == 0) then
		mw.log('HonorUtils.getHonorVariants: There are no '..variantType..' variants!')
		return nil
	end
	mw.log('HonorUtils.getHonorVariants (cntOfVariants): '..cntOfVariants)
	local actVariant = 0
	local tVariantArguments = {}
	for actVariant = 1, cntOfVariants, 1 do
		mw.log('HonorUtils.getHonorVariants (actVariant): '..actVariant)
		tVariantArguments[actVariant] = variantType .. '_' .. actVariant
	end
	local strVariantArguments = mw.text.listToText(tVariantArguments, ':', ':')
	mw.log('HonorUtils.getHonorVariants (strVariantArguments): '..strVariantArguments)
	local strVariant = p.getHonorMetadata(src, strVariantArguments, srcIsHonor)
	strVariant = mw.ustring.gsub(strVariant,"[\n\r]", "")
	mw.log('HonorUtils.getHonorVariants (strVariant): '..strVariant)
	tVariants = mw.text.split(strVariant, '|', notUseLUAPattern)
	mw.log('HonorUtils.getHonorVariants (#tVariants): '..#tVariants)
	return tVariants
end

function p.getHonorMetadata(src, metadata, srcIsHonor)
	local frame = mw.getCurrentFrame()
	local lPage = ''
	if (src ~= '' and src ~= nil) then
		if (srcIsHonor == true) then
			lPage = 'AY Honors/' .. src
		else
			lPage = src
		end
	end
	lPage = frame:expandTemplate{ title = 'GetHonorLandingPage', args = {page = lPage}}
	return frame:preprocess( '{{#dpl:|debug=0|title=' .. lPage .. '|include={HonorLanding}:' .. metadata ..'}}' )
end

return p