Module:HonorUtils

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

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

-- retruns a table with the type and the number of the variant of the act. page
function p.getActVariantInfo( frame )
	local pageTitle = frame:expandTemplate{ title = 'PAGENAMEwithoutLang' }
	mw.log('HonorUtils.getActVariantInfo (pageTitle): '..pageTitle)
	local tPageTitle = mw.text.split(pageTitle, '/', notUseLUAPattern)
	
	local subPageString = tPageTitle[3]
	if (subPageString == nil) then
		mw.log('HonorUtils.getActVariantInfo: It is not a valid Subpage (nil)!')
		return nil
	end
	
	local variantNumber = utilities.getNumber(subPageString)
	if (variantNumber == nil) then
		-- if the page has no number then it is mostlikely number one
		-- and if it is an invalid subpage then the number won't be used anyway's
		variantNumber = 1
	end
	local tReturn = {
		variantNumber = variantNumber
	}
	-- check for valid subpages
	if ( mw.ustring.find(subPageString, 'Requirements', 0, notUseLUAPattern) ~= nil ) then
		mw.log('HonorUtils.getActVariantInfo: It is the Requirements Variant '..variantNumber)
		tReturn['variantType'] = 'requirements'
		tReturn['subPage'] = 'Requirements'
	elseif (mw.ustring.find(subPageString, 'Answer Key', 0, notUseLUAPattern) ~= nil ) then
		mw.log('HonorUtils.getActVariantInfo: It is the Answer Key Variant '..variantNumber)
		tReturn['variantType'] = 'answerKey'
		tReturn['subPage'] = 'Answer Key'
	else
		mw.log('HonorUtils.getActVariantInfo: It is a Subpage with no possibility for variants')
		return nil
	end
	return tReturn
end

function p.getVariantsData( frame, landingPage, variantType, variantNumber )
	if ( frame == nil ) then
		frame = mw.getCurrentFrame()
		mw.log( 'HonorUtils.getVariantsData (frame): '..frame:getTitle() )
	end
	if ( landingPage == nil or landingPage == "" ) then
		landingPage = frame:expandTemplate{ title='GetHonorLandingPage' }
	end
	local srcIsHonor = false
	local getAnswerVariants = true
	local tAnswerVariants = nil
	local getRequirementVariants = true
	local tRequirementVariants = nil
	
	-- check if only one variant is needed
	if ( variantType ~= nil and variantType ~= '' ) then
		if (variantType == 'requirements') then
			getAnswerVariants = false
		elseif (variantType == 'answerKey') then
			getRequirementVariants = false
		else
			mw.log( 'HonorUtils.getVariantData: Invalid variantType!' )
			return nil;
		end
	end

	if ( getAnswerVariants == true ) then
		tAnswerVariants = getHonorVariants( 'answerKey', landingPage, srcIsHonor, variantNumber )
		if ( tAnswerVariants == nil ) then
			mw.log("HonorUtils.getVariantsData: It isn't possible to get any answer variant's data!")
		end
	end
	
	if ( getRequirementVariants == true ) then
		tRequirementVariants = getHonorVariants( 'requirements', landingPage, srcIsHonor, variantNumber )
		if ( tRequirementVariants == nil ) then
			mw.log("HonorUtils.getVariantsData: It isn't possible to get any requirement variant's data!")
		end
	end
	
	local tVariants = {
		answers = tAnswerVariants,
		requirements = tRequirementVariants
	}
	
	tVariants = expandHonorVariants( frame, tVariants )
	
	tVariants = translateHonorVariants( frame, tVariants )
	return tVariants
end

function expandHonorVariants( frame, tVariants )
	local tRetVariants = tVariants
	if ( tVariants == nil ) then
		mw.log('HonorUtils.expandHonorVariants: No Variants to Expand (nil)!')
		return {}
	end
	if ( tVariants['answers'] == nil ) then
		mw.log('HonorUtils.expandHonorVariants: No Answer Variants to Expand!')
	else
		-- expand the answer Variants
		local tAnswers = tVariants['answers']
		mw.log('HonorUtils.expandHonorVariants: There are '..#tAnswers..' Answer Variants to Expand!')
		for key, variant in pairs(tAnswers) do
			mw.log('HonorUtils.expandHonorVariants (key, variant): '..key..', '..variant)
			local tActVariant = {
				orig = variant,
				countries = {}
			}
			
			-- seperate the source language suffix
			local tSplitAnsVariant = mw.text.split(variant, '/', notUseLUAPattern)
			if (tSplitAnsVariant[2] ~= nil and tSplitAnsVariant[2] ~= '') then
				tActVariant['srcLangSuffix'] = '/'..tSplitAnsVariant[2]
				mw.log('HonorUtils.expandHonorVariants (srcLangSuffix): '..tActVariant['srcLangSuffix'])
			else
				mw.log('HonorUtils.expandHonorVariants: There is no source language set, default to english, which is an empty string ;)')
				tActVariant['srcLangSuffix'] = ''
			end
			
			-- seperate Countries and Authority
			tSplitAnsVariant = mw.text.split(tSplitAnsVariant[1], ';;', notUseLUAPattern)
			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.expandHonorVariants (Countries - Orig): '..tActVariant['countries']['orig'])
			else
				mw.log('HonorUtils.expandHonorVariants: There are no countries for that variant!')
			end
			-- set the authority
			if ( tSplitAnsVariant[2] == nil ) then
				tActVariant['authority'] = nil
				mw.log('HonorUtils.expandHonorVariants (Authority): nil')
			else
				tActVariant['authority'] = tSplitAnsVariant[2]
				mw.log('HonorUtils.expandHonorVariants (Authority): '..tActVariant['authority'])
			end
			-- save act. Variant into the table
			tAnswers[key] = tActVariant
		end
		tVariants['answers'] = tAnswers
		mw.log('HonorUtils.expandHonorVariants: '..#tVariants['answers']..' Answer Variants expanded!')
	end
	if ( tVariants['requirements'] == nil ) then
		mw.log('HonorUtils.expandHonorVariants: No Requirement Variants to Expand!')
	else
		-- expand the requirement Variants
		local tRequirements = tVariants['requirements']
		mw.log('HonorUtils.expandHonorVariants: There are '..#tRequirements..' Requirement Variants to Expand!')
		for key, variant in pairs(tRequirements) do
			mw.log('HonorUtils.expandHonorVariants (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.expandHonorVariants: '..#tVariants['requirements']..' Requirement Variants expanded!')
	end
	return tRetVariants
end

function translateHonorVariants( frame, tVariants )
	local tRetVariants = tVariants
	if ( tRetVariants == nil ) then
		mw.log('HonorUtils.translateHonorVariants: There are no Variants (nil)!')
	end
	if ( tRetVariants['answers'] == nil ) then
		mw.log('HonorUtils.translateHonorVariants: There are no Answer Variants!')
	else
		mw.log('HonorUtils.translateHonorVariants: 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.translateHonorVariants: Answer Variant is invalid!')
			else
				mw.log('HonorUtils.translateHonorVariants: 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.translateHonorVariants (country, trans): '..country..', '..trans)
					if ( trans == '' ) then
						trans = country
					end
					tRetVariants['answers'][varKey]['countries']['split'][countryKey] = {
						orig = country,
						translated = trans
					}
				end
				mw.log('HonorUtils.translateHonorVariants: '..#tRetVariants['answers'][varKey]['countries']['split']..' Answer Variant Countries were translated!')
			end
		end
		mw.log('HonorUtils.translateHonorVariants: '..#tRetVariants['answers']..' Answer Variants were translated!')
	end
	if ( tRetVariants['requirements'] == nil ) then
		mw.log('HonorUtils.translateHonorVariants: There are no Requirement Variants!')
	else
		mw.log('HonorUtils.translateHonorVariants: 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.translateHonorVariants: Requriement Variant is invalid!')
			else
				mw.log('HonorUtils.translateHonorVariants: 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.translateHonorVariants: '..#tRetVariants['requirements'][varKey]['authorities']..' Requriement Variant Authorities were translated!')
			end
		end
		mw.log('HonorUtils.translateHonorVariants: '..#tRetVariants['requirements']..' Requriement Variants were translated!')
	end
	return tRetVariants
end

function getHonorVariants( variantType, src, srcIsHonor, variantNumber )
	local frame = mw.getCurrentFrame()
	local parentFrame = frame:getParent()
	mw.log('HonorUtils.getHonorVariants (frame): '..frame:getTitle())
	local onLandingPage = false
	local useVarDefine = false
	if (variantType == nil or variantType == '') then
		variantType = 'requirement'
	end
	local cntOfVariantsArgString = 'cnt_'..variantType..'_variants'
	local cntOfVariants = tonumber(p.getHonorMetadata(src, cntOfVariantsArgString, srcIsHonor))
	if (cntOfVariants == nil or cntOfVariants == 0) then
		-- check if we are on the honor landing page, if so check the template's argument's
		if ( parentFrame ~= nil and
			 parentFrame:getTitle() == 'Template:HonorLanding'
			) then
			onLandingPage = true
			if ( parentFrame.args[cntOfVariantsArgString] ~= nil and 
			     parentFrame.args[cntOfVariantsArgString] ~= '' ) then
				cntOfVariants = parentFrame.args[cntOfVariantsArgString]
			else
				useVarDefine = true
				cntOfVariants = utilities.getVar(cntOfVariantsArgString)
			end
		else
			mw.log('HonorUtils.getHonorVariants: There are no '..variantType..' variants!')
			return nil
		end
	end
	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 = {}
	variantNumber = tonumber(variantNumber)
	if ( variantNumber ~= nil ) then
		-- only get the defined Variant
		if ( variantNumber <= cntOfVariants ) then
			tVariantArguments[1] = variantType..'_'..variantNumber
		else
			mw.log('HonorUtils.getHonorVariants: invalid variantNumber ('..variantNumber..')!')
			return nil
		end
	else
		-- get all variants
		for actVariant = 1, cntOfVariants, 1 do
			mw.log('HonorUtils.getHonorVariants (actVariant): '..actVariant)
			tVariantArguments[actVariant] = variantType .. '_' .. actVariant
		end
	end
	
	local tVariants = {}
	if ( onLandingPage == true ) then
		for key, variantArg in pairs(tVariantArguments) do
			if ( useVarDefine == false ) then
				tVariants[key] = parentFrame.args[variantArg]
			else
				tVariants[key] = utilities.getVar(variantArg)
			end
		end
	else
		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)
	end
	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