--------------------------------------------------------------------------------

--                                                                            --

--      This meta-module which automatically detects namespaces, and allows   --

--      for a great deal of customisation. It can easily be ported to other   --

--      wikis by changing the values in the [[Module:Pagetype/config]].       --

--                                                                            --

--------------------------------------------------------------------------------

-- Load config.

local cfg = mw.loadData('Module:Pagetype/config')



-- Load required modules.

local yesno = require('Module:Yesno')

local p = {}



-- Look up a namespace argument in the args table.

local function lookUpNamespaceArg(args, key)

	local arg = argskey

	-- Convert "yes", "1" etc. to true, "no", "0" etc. to false, and leave

	-- other values the same.

	return yesno(arg, arg)

end



-- Append multiple values to an array

local function appendMultiple(target, source)

	for _, value in ipairs(source) do

		table.insert(target, value)

	end

end



-- Get argument keys for a title's namespace

local function getNamespaceArgKeys(title)

	local nsInfo = mw.site.namespacestitle.namespace

	local customAliases = cfg.customNamespaceAliasestitle.namespace or {}

	local keys = {}

	if nsInfo.name ~= '' then

		table.insert(keys, nsInfo.name)

	end

	if nsInfo.canonicalName ~= nsInfo.name and nsInfo.canonicalName ~= '' then

		table.insert(keys, nsInfo.canonicalName)

	end

	appendMultiple(keys, nsInfo.aliases)

	appendMultiple(keys, customAliases)

	return keys

end



-- Get the argument for a title's namespace, if it was specified in the args table.

local function getNamespaceArg(title, args)

	if title.isTalkPage then

		return lookUpNamespaceArg(args, cfg.talk)

	end

	for _, key in ipairs(getNamespaceArgKeys(title)) do

		local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))

		if arg ~= nil then

			return arg

		end

	end

	return nil

end



-- Look up a page type specific to the title's namespace

local function getExplicitPageType(title)

	if title.isTalkPage then

		return cfg.talkDefault

	else

		return cfg.pagetypestitle.namespace

	end

end



-- Get a default page type that is not specific to the title's namespace

local function getDefaultPageType(args)

	local other = lookUpNamespaceArg(args, cfg.other)

	if type(other) == 'string' then

		return other

	else

		return cfg.otherDefault

	end

end



local function detectRedirects(title, args)

	local redirect = lookUpNamespaceArg(args, cfg.redirect)

	if redirect == false then

		-- Don't detect redirects if they have been specifically disallowed.

		return nil

	end



	-- Allow custom values for redirects.

	if not title.isRedirect then

		return nil

	elseif type(redirect) == 'string' then

		return redirect

	else

		return cfg.redirectDefault

	end

end



local function capitalize(pageType)

	local first = mw.ustring.sub(pageType, 1, 1)

	local rest = mw.ustring.sub(pageType, 2)

	return mw.ustring.upper(first) .. rest

end



local function pluralize(pageType)

	if cfg.irregularPluralspageType then

		return cfg.irregularPluralspageType

	else

		return pageType .. cfg.plural -- often 's'

	end

end



local function parseContent(title, args, optionsList)

	if title.namespace==828 and title.subpageText~='doc' -- don't detect modules

		or not title.exists -- can't check unless page exists

	then

		return nil

	end

	local content = title:getContent()

	if content == nil then

		return nil

	end

	local templates -- lazily evaluated

	for _, options in next, optionsList do

		local list, parameter, default, articleOnly = unpack(options, 1, 4)

		if not articleOnly or title.namespace==0 then -- only check for templates if we should...

			local out = lookUpNamespaceArg(args, parameter)

			if type(out) == "string" or (out ~= false and default) then -- ...and if we actually have anything to say about them

				if not templates then

					templates = {} -- do our delayed evaluation now that we are required to

					content = require('Module:Wikitext Parsing').PrepareText(content) -- disregard templates which do not have any affect

					for template in string.gmatch(content, "{{%s*([^|}]-)%s*[|}]") do

						templates#templates+1 = capitalize(template)

					end

				end

				local wantedTemplates = mw.loadData('Module:Pagetype/' .. list)

				local templateFound = false

				for _, template in next, templates do

					if wantedTemplatestemplate then

						templateFound = true

						break

					end

				end

				if templateFound then

					if type(out)=='string' then

						return out

					elseif out ~= false and default then

						return default

					end

				end

			end

		end

	end

end



-- Find pages which do not exist

local function nonExistent(title, args)

	local arg = lookUpNamespaceArg(args, cfg.ne)

	if arg == false then

		return nil

	end

	local exists = false

	if title.exists then -- not an article if it does not exist

		exists = true

	elseif title.namespace==8 and mw.message.new(title.text):exists() then

		exists = true

	elseif title.namespace==6 and title.fileExists then

		exists = true

	end

	if not exists then

		if type(arg) == 'string' then

			return arg

		else

			return cfg.naDefault

		end

	end

end



-- Get page types for mainspaces pages with an explicit class specified

local function getMainNamespaceClassPageType(title, args)

	local class = args1

	if type(class) == 'string' then	-- Put in lower case so e.g. "na" and "NA" will both match

		class = mw.ustring.lower(class)

	end

	local arg = lookUpNamespaceArg(args, cfg.na)

	if arg == false then -- don't check for this class if it is specifically disallowed

		return nil

	end

	if cfg.naAliasesclass then

		if type(arg) == 'string' then

			return arg

		else

			return cfg.naDefault

		end

	else

		return nil

	end

end



-- Get page type specified by an explicit namespace argument.

local function getNamespaceArgPageType(title, args)

	local namespaceArg = getNamespaceArg(title, args)

	if namespaceArg == true then

		-- Namespace has been explicitly enabled, so return the default for

		-- this namespace

		return getExplicitPageType(title)

	elseif namespaceArg == false then

		-- Namespace has been explicitly disabled

		return getDefaultPageType(args)

	elseif namespaceArg then

		-- This namespaces uses custom text

		return namespaceArg

	else

		return nil

	end

end





-- Get page type not specified or detected by other means

local function getOtherPageType(title, args)

-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.

	local isInDefaultActiveNamespace = false

	local defaultNamespacesKey = argscfg.defaultns

	if defaultNamespacesKey == cfg.defaultnsAll then

		isInDefaultActiveNamespace = true

	else

		local defaultNamespaces

		if defaultNamespacesKey == cfg.defaultnsExtended then

			defaultNamespaces = cfg.extendedNamespaces

		elseif defaultNamespacesKey == cfg.defaultnsNone then

			defaultNamespaces = {}

		else

			defaultNamespaces = cfg.defaultNamespaces

		end

		isInDefaultActiveNamespace = defaultNamespacestitle.namespace

	end

	if isInDefaultActiveNamespace then

		return getExplicitPageType(title)

	else

		return getDefaultPageType(args)

	end

end



function p._main(args)

	local title

	if args.page then

		title = mw.title.new(args.page)

	else

		title = mw.title.getCurrentTitle()

	end

	if title and not yesno(args.talk, true) and argscfg.defaultns ~= cfg.defaultnsAll then

		title = title.subjectPageTitle

	end

	local pageType = detectRedirects(title, args)

		or nonExistent(title, args)

		or parseContent(title, args, {

			{'softredirect', cfg.softRedirect, cfg.softRedirectDefault},

			{'setindex', cfg.sia, cfg.siaDefault, true},

			{'disambiguation', cfg.dab, cfg.dabDefault, true},

			{'rfd', cfg.rfd, cfg.rfdDefault},

		})

		or (title.namespace == 0 and getMainNamespaceClassPageType(title, args))

		or getNamespaceArgPageType(title, args)

		or getOtherPageType(title, args)

	if yesno(args.plural, false) then

		pageType = pluralize(pageType)

	end

	if yesno(args.caps, false) then

		pageType = capitalize(pageType)

	end

	return pageType

end



function p.main(frame)

	local args = require('Module:Arguments').getArgs(frame)

	return p._main(args)

end



return p