Module:Date complexe

local datemodule = require('Module:Date')
local linguistic = require('Module:Linguistique')
local p = {}

local numericprecision = { -- convertir les précisions en valeurs numériques = à celles utilisées par Wikidata
	gigayear = 0,
	megayear = 3,
	millenium = 6,
	century = 7,
	decade = 8,
	year = 9,
	month = 10,
	day = 11,
	hour = 12,
	minute = 12,
	second = 14,
}

local function vowelfirst(str)
	return linguistic.vowelfirst(str)
end

local function guessprecision(obj) -- précision des dates qui ne viennent pas de Module:Wikidata/Dates
	local prec = 0
	for i, j in pairs(obj) do
		if (numericprecision[i] or 0) > prec then
			prec = numericprecision[i]
		end
	end 
	return prec
end

local function centuryString(centurynumber)
	return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { centurynumber + 1 }} .. '<sup>e</sup> siècle'
end

local function centuryString(centurynumber)
	return mw.getCurrentFrame():expandTemplate{ title = 'Nombre en romain', args = { centurynumber + 1 }} .. '<sup>e</sup> millénaire'
end

local function decadeString(decadenumber)
	return 'années ' .. decade .. '0'
end

function p.simplestring(dateobject) 
	-- transforme un object date ponctuel en texte
	-- les dates de type ISO devraient passer par Module:Date, mais il faut pouvoir désactiver les liens
	local yearstr, monthstr, daystr= tostring(dateobject.year), tostring(dateobject.month), tostring(dateobject.day)

	-- adaptation à mw.formatDate en attendant de passer par Module:Date
	if yearstr then
		while #yearstr < 4 do
			yearstr = 0 .. yearstr
		end
	end

	local era = dateobject.era
	local precision = dateobject.precision or guessprecision(dateobject)
	
	if precision == 6 then
		local century = tostring(math.floor(dateobject.year/100))
		str = centuryString(century)
	elseif precision == 7 then
		local century = tostring(math.floor(dateobject.year/100))
		str = centuryString(century)
	elseif precision == 8 then
		local decade = tostring(math.floor(dateobject.year/10)) 
		str = decadestring(decade)
	elseif precision == 9 then
		str = yearstr
	elseif precision == 10 then
		str =mw.language.new('fr'):formatDate('F Y', yearstr .. '-' .. monthstr ) 
		if dateobject.year < 1000 then -- enlève les zéros en trop
			str = string.gsub(str, '0', '')
		end
	elseif precision == 11  then
		str = 	mw.language.new('fr'):formatDate('j F Y', yearstr .. '-' .. monthstr .. '-' .. daystr)
		if day == 1 then -- ajustement "1 janvier" -> 1er janvier
			str = string.gsub(t, '1', "1<sup>er</sup>", 1) -- remplacer "1 janvier" par "1er janvier"
		end
		if dateobject.year < 1000 then 
			str = string.gsub(str, '0', '')
		end
	end
	if era == '-' then
		str = str .. ' av. J.-C.'
	end
	return str or 'date invalide'
end

local function fromdate(d)  -- retourne "à partir de date" en langage naturel
	local precision = d.precision or guessprecision(d)
	local datestr = p.simplestring(d)

	if (precision >= 11) or (precision == 7) or (precision == 6)  then -- ont dit "à partir du pour les dates avec jour, les siècles, les millénaires
		return 'à partir du ' .. datestr
	else
		if vowelfirst(str) then
			return "à partir d'" .. datestr
		else
			return 'à partir de ' .. datestr
		end
	end
end

local function upto(d)  -- retourne "jusqu'à date' en langage naturel
	local datestring = p.simplestring(d)
	local precision = d.precision or guessprecision(d)
	if (precision >= 11) or (precision == 7) or (precision == 6) then --on dit "jusqu'au" pour les dates avec jour, et pour les siècles
		return 'jusqu\'au ' .. datestring
	elseif (precision >= 9) then
		return "jusqu'à " .. datestring
	else
		return "jusqu\'en " .. datestring
	end
end

local function fromuntillong(startstr, endstr) -- inutile ?
	-- on dit "du 3 au 14 janvier" mais "de septembe à octobre
	if precision >= 11 then -- >= day
		return "du " .. startstr .. " au " ..  endstr
	else
		if vowelfirst(startstr) then
			return "d'" .. startstr .. " à ".. endstr
		else
			return "de " .. startstr .. " à " .. endstr
		end
	end
end

local function fromuntil(startpoint, endpoint)
	local precision = endpoint.precision or guessprecision(endpoint) -- may need 2 precisions for start and end dates

	local startstr = p.simplestring(startpoint)
	local endstr = p.simplestring(endpoint)
	-- à améliorer pour éviter les tournures répétitives comme  "du 13 septembre 2006 au 18 september 2006"
	if not params then
		params = {}
	end
	if params.displayformat == 'long' then
		return fromuntillong(startstr, endstr)
	else
		return startstr .. '-' .. endstr
	end
end

function p.fuzzydate(dateobjet)
	local str = p.simplestring(dateobject)
	return "vers " .. str
end

function p.daterange(startpointobject, endpointobject) 
	if startpointobject and endpointobject then
		return fromuntil(startpointobject, endpointobject)
	elseif startpointobject then
		return fromdate(startpointobject)
	elseif endpointobject then
		return upto(endpointobject)
	else
		return nil
	end
end

return p