Belgekirina modulê[biafirîne]
local p = {}


--
-- Les modules et sous-modules dont on aura besoin
--

-- le module démographie
p.demographie = require("Module:Demografî")
-- le module chartes
p.chartes = require("Module:Chartes")

-- on charge les sous-modules
p.constantes = require("Module:Nifûsa Fransa/berdewam")
p.sources = require("Module:Nifûsa Fransa/çavkanî")
p.notes = require("Module:Nifûsa Fransa/not")
p.donnees = require("Module:Nifûsa Fransa/dane")
p.outils = require("Module:Nifûsa Fransa/hacet")
p.intro = require("Module:Nifûsa Fransa/pêşgotin")


--[[
  fonction récupérant les différentes données et appelant
  le module démographie pour l'affichage effectif
--]]
function p.tableau_m(param)
	-- le nom de la cible (param. nom ou titre page)
	local ttl = mw.title.getCurrentTitle().subpageText
	local wlm = false
	local vnom = param["nom"] or ttl
	local donnees = "Module:Dane/" .. vnom .. "/pêşveçûna nifûsê"
	
	-- on charge les données
	local data, wlm = p.donnees.charge_donnees(vnom, false)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("tableau", donnees, wlm)
	end

	-- on prépare les paramètres à fournir au module Démographie
	local dest = {}
	
	-- éléments constants
	dest["largeur_tableau"] = "48em"
	dest["taille_police"] = "95%"
	dest["marge_interlignes"] = "10px"
	dest["hauteur_lignes"] = "110%"
	dest["population_fond"] = "#F9F9F9"
	dest["style_notes"] = "centré"
	
	-- couleur (on passe par Chartes avec un "truc" pour commune nouvelle)
	if (data["division"] == "commune nouvelle") then
		dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", "commune", true)
	else
		dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", data["division"], true)
	end

	-- le titre du tableau
	dest["titre"] = (param["titre"] or p.constantes.titre_tableau)
		.. " &nbsp;<small>[&#8202;[[" .. donnees .. "|modifier]]&#8202;]</small>"
	
	-- notes
	local tmp = p.notes.notes(data, vnom)
	if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
		dest["notes"] = tmp
	end
	
	-- sources
	tmp = p.sources.sources(data)
	if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
		dest["sources"] = tmp
	end
	
	-- maintenant on parcours les données elles-mêmes
	for annee, pop in pairs(data) do
		-- les années sont les éléments numériques du tableau
		if (type(annee) == "number") then
			-- est-ce qu'on garde l'année ?
			if (p.outils.test_annee(annee, data)) then
				vpop = tonumber(mw.text.trim(pop["pop"]))
				if (vpop > 0) then
					dest[annee] = vpop  -- on stocke
				else
					dest[annee] = "-"
				end
			end
		end
	end

	-- on effectue l'appel terminal et on retourne (et on ajoute la catégorie)
	return p.demographie.demographie_m(dest) .. p.constantes.cat_usage
end

-- fonction "wrapper" pour la précédente, pour appel depuis un modèle
function p.tableau(frame)
	local param = {}
	-- deux paramètres : nom et titre
	param["nom"] = p.outils.nettoie(frame.args["nom"] or frame:getParent().args["nom"] or nil)
	param["titre"] = p.outils.nettoie(frame.args["titre"] or frame:getParent().args["titre"] or nil)

	-- on appelle la vraie fonction
	return p.tableau_m(param)
end

--[[
  Fonction créant une introduction de population de commune
--]]
function p.introduction_m(param)
	local resu
	local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Dane/" .. nom .. "/pêşveçûna nifûsê"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("introduction", donnees, wlm)
	end
	if (data["division"] == "fraction cantonale") then
		return p.outils.err_nodata("introduction", donnees, 6) -- pas d'intro pour ça
	end
	
	resu = p.intro.introduction(data)

	return resu
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.introduction(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération de l'unique paramètre (nom)
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	return p.introduction_m(param)	
end


-- fonction de tri utilisée par la fonction suivante
-- tri sur la valeur du 1er élément des éléments
function p.sort_par_annee(el1, el2)
	if (el1[1] < el2[1]) then
		return true
	end
	return false
end

--[[
  Fonction créant un graphique de population de commune
--]]
function p.graphique_m(param)
	local resu
	local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Dane/" .. nom .. "/pêşveçûna nifûsê"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("graphique", donnees, wlm)
	end
	if (data["division"] == "fraction cantonale") then
		return p.outils.err_nodata("graphique", donnees, 6) -- pas d'intro pour ça
	end

	-- seuil (nombre de données) pour afficher
	param["seuil"] = tonumber(param["seuil"])
	if ((param["seuil"] == nil) or (param["seuil"] <= 0)) then
		param["seuil"] = 5 -- valeur par défaut
	end

	-- "Histogramme population manuel" étant un modèle, on fabrique la structure d'appel
	-- ici il faudrait modifier "couleur-barres" qui devrait dépendre de la charte…
	prm = { ["largeur"] = 710, ["hauteur"] = 340, ["couleur-fond"] = "rgb(1,1,1)" }
	local cb
	if (data["division"] == "commune nouvelle") then
		cb = p.chartes.charte_m("geographie", "primaire", "commune", true)
	else
		cb = p.chartes.charte_m("geographie", "primaire", data["division"], true)
	end
	cb = p.outils.color2rgb(cb)
	if (cb == nil) then
		prm["couleur-barres"] = "rgb(0.7,0.9,0.7)" -- couleur "par défaut"
	else
		prm["couleur-barres"] = "rgb(" .. cb .. ")"
	end

	prm["nom"] = param["nom"]
	prm["titre"] = param["titre"] or p.constantes.titre_graphique
	prm["max"] = data["popmax"]
	-- parcours des données
	local tmp = {}
	for annee, pop in pairs(data) do
		if (type(annee) == "number") then
			-- est-ce qu'on garde l'année ?
			if (p.outils.test_annee(annee, data) and (type(pop["pop"]) == "number") and (pop["pop"] > 0)) then
				table.insert(tmp, { annee, pop["pop"] })
			end
		end
	end

	-- tri des éléments
	table.sort(tmp, p.sort_par_annee)
	-- on insert année / valeur dans l'ordre (histogramme pop… a besoin des données dans l'ordre)
	local nb = 1
	local nbp = 0
	for k, v in pairs(tmp) do
		if (v[2] > 0) then
			prm[nb] = v[1]
			prm[nb+1] = v[2]
			nb = nb + 2
			nbp = nbp + 1  -- nombre de barres (réel)
		end
	end
	-- si pas assez de données on ne traite pas
	if (nbp < param["seuil"]) then
		return ""  -- on retourne "rien"
	end

	prm["nombre"] = nbp
	prm["sources"] = p.sources.sources_graphique(data)

	-- précaution
	if (nbp == 0) then
		p.outils.err_nodata("graphique", donnees, 7, true)
	end

	-- on "appelle" le modèle
	return mw.getCurrentFrame():expandTemplate{ title = 'Histogramme population manuel', args = prm }
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.graphique(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["titre"] = p.outils.nettoie(frame.args["titre"] or pframe.args["titre"] or nil)
	param["seuil"] = p.outils.nettoie(frame.args["seuil"] or pframe.args["seuil"] or nil)
	return p.graphique_m(param)	
end


--[[
  Retourne la dernière population (ou la dernière date) pour la commune "nom" (ou courante)
  Si prm[1] est vide retourne la population, sans formatage
  Si prm[1] vaut "date", retourne la date
  Si prm[1] vaut "nombre", idem premier cas mais avec formatage du nombre
  Si prm[1] vaut "table", retourne une table avec l'année en 1er élément et le nombre en 2e élément
--]]
function p.derniere_population_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Dane/" .. nom .. "/pêşveçûna nifûsê"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("derniere_population", donnees, wlm, true)
	end
	
	local tmp = p.donnees.valeur_recente(data)
	if (tmp == nil) then
		return p.outils.err_nodata("derniere_population", donnees, 7, true)
	end
	
	if (prm["type"] == "table") then
		return tmp
	end
	if (prm["type"] == "date") then
		return tmp[1]
	end
	if ((prm["type"] == nil) or (mw.text.trim(prm["type"]) == "")) then
		return tmp[2]
	end
	return mw.language.getContentLanguage():formatNum(tmp[2])
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.derniere_population(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = p.outils.nettoie(frame.args[2] or pframe.args[2] or nil)
	param["type"] = frame.args[1] or pframe.args[1] or nil
	return p.derniere_population_m(param)	
end


--[[
  Retourne une phrase décrivant la variation de population de la commune
    courante (ou "nom") ou un pictograme si "type" = "picto"
--]]
function p.variation_texte_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Dane/" .. nom .. "/pêşveçûna nifûsê"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("variation_texte", donnees, wlm, true)
	end
	
	local txt, sens = p.donnees.variation_texte(data)
	if (txt == nil) then
		return p.outils.err_nodata("variation_texte", donnees, 7, true)
	end
	if (prm["type"] ~= "picto") then
		return txt
	end
	-- on crée le pictogramme
	if (sens > 0) then
		return "[[Wêne:Increase2.svg|11px|link=|class=noviewer|" .. txt .. "]]"
	elseif (sens < 0) then
		return "[[Wêne:Decrease2.svg|11px|link=|class=noviewer|" .. txt .. "]]"
	else -- égal
		return "[[Wêne:steady.svg|10px|link=|class=noviewer|" .. txt .. "]]"
	end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.variation_texte(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["type"] = frame.args["type"] or pframe.args["type"] or nil
	return p.variation_texte_m(param)	
end


--[[
  Retourne la densité de la commune. Si "précision" indiquée utilise celle-ci,
  sinon précision 1 par défaut
--]]

function p.densite_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Dane/" .. nom .. "/pêşveçûna nifûsê"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("densite", donnees, wlm, true)
	end

	local prc = 1
	if (type(prm["précision"]) == "number") then
		prc = prm["précision"]
	end
	if ((data[data["derniere"]]["pop"] == nil) or (data["superficie"] == nil)) then
		return p.outils.err_nodata("densite", donnees, 7, true)
	end
	
	if (prm["format"] ~= nil) then
		return mw.language.getContentLanguage():formatNum(
			p.outils.round(data[data["derniere"]]["pop"] / data["superficie"], prc))
	else
		return p.outils.round(data[data["derniere"]]["pop"] / data["superficie"], prc)
	end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.densite(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["précision"] = tonumber(frame.args["précision"] or pframe.args["précision"] or nil)
	param["format"] = frame.args["format"] or pframe.args["format"] or nil
	return p.densite_m(param)	
end


--[[
  Retourne la superficie de la commune. 
--]]

function p.superficie_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Dane/" .. nom .. "/pêşveçûna nifûsê"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("superficie", donnees, wlm, true)
	end

	return (data["superficie"])

end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.superficie(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	return p.superficie_m(param)	
end
return p