Módulo:Data

local fun = {}

local Ferramentas = require 'Módulo:Ferramentas'
-- carregando o banco de dados listando algumas páginas existentes para evitar "ifexist".
local dataLinks
local success, resultado = pcall ( mw.loadData, 'Módulo:Data/Dados' )
if success then
    dataLinks = resultado
else
    -- proteção no caso ou sub módulos serem mal modificados
    dataLinks = { [''] = { mes = { vazio = 1000, todos = { 1773, 2014 } }, } }
end

-- limpa um parâmetro sem nome (vira os espaços no começo e no fim)
-- voltar nil se o texto estiver vazio ou não estiver enviando mensagens de texto. A atenção é importante para a função que a utiliza.
local trim = Ferramentas.trim

-- Função destinada a meter a primeira letra do mês em minúscula do mês :
-- uso de string porque nenhum mês começa com uma letra não ascii em português ou inglês.
local function lcfirst( str )
    return str:sub( 1, 1 ):lower() .. str:sub( 2 )
end


-- lista de meses, escritas exatamente com alias, em minúscula
local listaMes = {
    { num = 1,    nDia = 31, abrev = 'jan.',    nome = 'janeiro', alias = { 'jan.', 'jan.', 'jan', 'janeiro', 'january'} },
    { num = 2,    nDia = 29, abrev = 'fev.',     nome = 'fevereiro', alias = { 'fevereiro', 'fev.', 'fev', 'february'} },
    { num = 3,    nDia = 31, abrev = 'mar.',     nome = 'março', alias = { 'mar.', 'mar', 'março', 'march' } },
    { num = 4,    nDia = 30, abrev = 'abr.',     nome = 'abril', alias = { 'abr.', 'abr','abril', 'april' } },
    { num = 5,    nDia = 31, abrev = 'maio',      nome = 'maio', alias = { 'maio', 'may' } },
    { num = 6,    nDia = 30, abrev = 'jun.',     nome = 'junho', alias = { 'jun', 'june' } },
    { num = 7,    nDia = 31, abrev = 'jul.', nome = 'julho', alias = { 'jul.', 'july' } },
    { num = 8,    nDia = 31, abrev = 'ago.',     nome = 'agosto', alias = { 'ago', 'august' } },
    { num = 9,    nDia = 30, abrev = 'set.',    nome = 'setembro', alias = { 'set', 'set.', 'setembro', 'september' } },
    { num = 10, nDia = 31, abrev = 'out.',     nome = 'outubro', alias = { 'out', 'out.', 'october' } },
    { num = 11, nDia = 30, abrev = 'nov.',     nome = 'novembro', alias = { 'nov', 'nov.', 'november' } },
    { num = 12, nDia = 31, abrev = 'dez.',     nome = 'dezembro', alias = { 'dezembro',  'dez.', 'dez', 'december' } },

}

-- adicionar nomes, abreviaturas e aliases como uma lista de keyMonth listaMes
for i = 1, 12 do
    local mes = listaMes[ i ]
    listaMes[ tostring( i ) ] = mes
    listaMes[ '0' .. i ] = mes
    listaMes[ mes.nome ] = mes
    listaMes[ mes.abrev ] = mes
    for _, n in ipairs( mes.alias ) do
    listaMes[ n ] = mes
    end
end
--for _, n in ipairs( listaMes.aout.alias ) do
--    listaMes[ n ] = listaMes.aout
--end
fun.listaMes = listaMes

local lista_estacao = {
    { 'Primavera', 'spring', },
    { 'Verão', 'summer', },
    { 'Outono', 'autumn', },
    { 'Inverno', 'winter', },
}

---
-- validadar que a string passada é uma valida.
-- devolver o nome completo ou nil se não for reconhecido
-- se reconhecido, também retorna o número de mes [1-12]
function fun.validaMes( mes )
    local m = trim( mes )
    if m then
    m = mw.ustring.lower( m )
    if listaMes[ m ] then
        return listaMes[ m ].nome, listaMes[ m ].num
    end
    end
end

---
-- validar que a string passada é uma estação valida.
-- devolver o nome completo ou nil se não for reconhecido
function fun.validaEstacao( estacao )
    local s = trim( estacao )
    if s then
    s = mw.ustring.lower( s )
    for i = 1, 4 do
        for _, n in ipairs( lista_estacao[i] ) do
        if s == n then
            return lista_estacao[i][1]
        end
        end
    end
    end
end

---
-- determinationMes encontrar o número do mes e seu nome,
-- do seu nome, seu número ou uma expressão matemática.
-- Se o segundo parâmetro for true, números maiores que 12 ou não inteiros serão aceites.
function fun.determinationMes( mes, mod, laco )
    local num, nome
    if tonumber( mes ) then
    num = math.floor( tonumber( mes ) )
    if mod then      
        -- se o número de mes é calculado por uma expressão, o resultado pode ser maior que 12, ou menor que 1
        num = math.fmod( num + 239, 12 ) + 1  -- +239 car fmod(-1) = -1 et non 11
    elseif num < 1 or num > 12 then
        num = nil
    end
    elseif trim( mes ) then
    nome, num = fun.validaMes( mes )
    if nome == nil and laco == nil then
        -- tente determinar um número com o analisador #expr do Mediawiki.
        -- o parâmetro laco evita o loop.
        nome, num = fun.determinationMes( mw.getCurrentFrame():callParserFunction( '#expr', mes ), true, true )
    end
    end
    if num and not nome then
    nome = listaMes[ num ].nome
    end
    return nome, num
end


--  função interna para modelData, para determinar se podemos fazer sem ifexitif
local function existData( dataQualificativo, ano, mes )
    local data
    if mes then
       data = dataQualificativo.mes
    else
    data = dataQualificativo.ano
    end
    if type( data ) ~= 'table' then
       -- Se os dados não existem, considera-se que não há link.
       return
    end
    -- o qualificador é substituído pelo do banco de dados, que permite aliases.
    local link = ano
    if dataQualificativo.qualificativo then
       link = link .. ' ' .. dataQualificativo.qualificativo
    end
    local singular = ano
    if mes then
       link = mes .. ' de ' .. link
       singular =      mes .. ' de ' .. ano
    end
    local vazio = tonumber( data.vazio )
    if vazio and ano <= vazio then
       -- se o ano está na parte "não", testamos se ainda há um link isolado
       if type( data.singular ) == 'table' then
             for i, v in ipairs( data.singular ) do
              if singular == v or singular == tonumber( v ) then
                   return link
              end
          end
       end
          -- parte não e nenhum link => nada
          return nil
       elseif type( data.todos ) == 'table' then
             local todos1, todos2 = tonumber( data.todos[1] ), tonumber( data.todos[2] )
          if todos1 and todos2 and ano >= todos1 and ano <= todos2 then
             -- o ano está no partido 'todos' então retornamos o link
             return link
          end
       end
       -- o ano não está nem na parte nem na parte de todos, então você tem que testar se a página existe.
       local alvoLink = mw.title.new( link )
       if alvoLink and alvoLink.exists then
          return link
       end
end

---
-- Exclui o dia da semana e "o" antes de um dado
function fun.limpezaDia( dia )
    if type( dia ) == 'string' then
    local nomeDia = { '[Ss]egunda-feira', '[Tt]erça-feira', '[Qq]uarta-feira', '[Qq]uinta-feira', '[Ss]exta-feira',
        '[Ss]ábado', '[Dd]omingo', '^ *[Oo]' }
--      local premier = { '<abbr class="abbr" title="[Pp]remier" ?>1<sup>er</sup></abbr>', '1<sup>er</sup>', '1er' }
    for i, v in ipairs( nomeDia ) do
        dia = dia:gsub( v, '' )
    end
--      for i, v in ipairs( premier ) do
--          dia = dia:gsub( v, '1' )
--      end
    dia = trim( dia )
    end
    return dia
end

---
-- Separa uma cadeia de data numa tabela com campos dia, mes e ano.
-- os dados devem conter o mês.
function fun.separationDiaMesAno( data )
    data = trim( data )
    if data then
    local function erro( periode, valor )
        return false, '<span class="error">' .. periode .. ' invalida (' .. valor .. ')</span>'
    end
    local dia, mes, ano, esconderMes, esconderAno, separador
    -- variável para construir as regex
    local j = '([0-3]?%d)'          -- dia
    local m = '([01]?%d)'         -- mês numérico
    local mmm =  '([^%s%p%d]+[.]?)' -- mês em todas as  letras
    local aj = '(%-?%d+)'         -- ano ou dia
    local s = '[ ./-de]+'          -- separador simples
--    local sep = '([ ./-de]+)'      -- separador com capture, para detectá-lo duas vezes que não é necesário
    local menos = '(%-?)'          -- o sinal menos para indicar que esses dados não devem ser exibidos
    local regexb = {
        jmmm = '^'..j..s..mmm..menos..'$',
        mmmjva = '^'..mmm..s..j..', ?'..aj..'$',
    }
   
    data = fun.limpezaDia( data )
    -- excluir categoria, links, tags
    data = mw.ustring.gsub( data, '%[%[[Cc]ategor[yi]a?:.-%]%]', '' )
    data = data    :gsub( '%b<>', '' )
            :gsub( '%[%[([^%[%]|]*)|?([^%[%]]*)%]%]', function ( l, t ) return trim( t ) or l end )
    -- remoção de espaços não quebráveis
            -- nbsp
            :gsub( '\194\160', ' ' )
            :gsub( '&nbsp;', ' ' )
            :gsub( '&#160;', ' ' )
            -- narrow nbsp
            :gsub( '\226\128\175', ' ' )
            :gsub( '&#8239;', ' ' )
            -- thin space
            :gsub( '\226\128\137', ' ' )
            :gsub( '&thinsp;', ' ' )
            :gsub( '&#8201;', ' ' )
            -- simple space
            :gsub( '&#32;', ' ' )
            -- vários espaços
            :gsub( ' +', ' ' )
    -- redução a.C. para simplificar um pouco de regex:
            :gsub( '(%d+) ?[Aa]%.? ?C%.?', '-%1' )
    -- exclusão de horas em dados ISO
            :gsub( '^+?([%d-]*%d%d%-%d%d)T%d%d[%d:,.+-]*Z?$' , '%1')
   
    -- teste de um ano
    if data:match( '^'..aj..'$' ) then
        ano = data:match( '^'..aj..'$' )
    elseif data:match( '^'..aj..s..aj..menos..'$' ) then
        -- dd/mm, mm/aaaa ou aaaa/mm
        local a, separador, b, sb = data:match( '^'..aj..s..aj..menos..'$' )
        a, b = tonumber( a ), tonumber( b )
        if separador:match( '^.+%-$' ) then
        -- provavelmente mm/-aaaa, ano a.C.
        b = 0 - b
        end
        if    a > 12 and ( b < 1 or b > 31 ) or
        b > 12 and ( a < 1 or a > 31 ) then
        return erro( 'Data', data )
        elseif b < 1 or b > 31 then
        mes, ano, esconderAno = a, b, sb
        elseif a < 1 or a > 31 then
        ano, mes  = a, b
        elseif b > 12 then
        return erro( 'Mes', b )
        else
        dia, mes, esconderMes = a, b, sb
        end
    elseif data:match( '^'..aj..s..m..menos..'%2'..s..aj..menos..'$' ) then
        -- dd/mm/aaaa ou aaaa/mm/dd
        dia, separador, mes, esconderMes, ano, esconderAno =     data:match( '^'..aj..s..m..menos..'%2'..s..aj..menos..'$' )
        if separador == '-' and esconderMes == '-' and esconderAno == '' and tonumber( ano ) > 0 then
        -- data no formato dd-mm--aaaa type 17-06--44 para 17 junho 44 a.C.
        esconderMes = nil
        ano = 0 - ano
        end
    elseif data:match( '^'..j..s..mmm..menos..'%2'..s..aj..menos..'$' ) then
        -- dd mmm aaaa
        dia, separador, mes, esconderMes, separador, ano, esconderAno = data:match( '^'..j..s..mmm..menos..'%2'..s..aj..menos..'$' )
    elseif data:match( '^'..mmm..s..aj..menos..'$' ) then
        -- mmm aaaa
        mes, separador, ano, esconderAno = data:match( '^'..mmm..s..aj..menos..'$' )
        if separador:match( '^.+%-$' ) then
        ano = '-' .. ano
        end
    elseif data:match( '^'..j..s..mmm..menos..'$' ) then
        -- dd mmmm
        dia, mes, esconderMes = data:match( '^'..j..s..mmm..menos..'$' )
    elseif data:match( '^'..mmm..s..j..', ?'..aj..'$') then
        -- mmm dd, aaaa (formato anglo-saxão)
        mes, dia, ano = data:match( '^'..mmm..s..j..', ?'..aj..'$')
    elseif data:match( '^'..mmm..'$' ) then
        mes = data
    else
        return erro( 'Data', data )
    end
    local jn, an = tonumber( dia ), tonumber( ano )
    if jn and an and ( jn > 31 or jn < 0 or #dia >= 3 ) and an <= 31 then
        -- caso particular dos dados ISO 2015-06-17, -0044-06-17 e -0002-06-17
        -- inversão do dia e do ano
        local temp = ano
        ano = dia
        dia = temp
    end
   
    return fun.validationDiaMesAno{
        dia, mes, ano,
        esconderAno = trim( esconderAno ) and true or nil,
        esconderMes = ( trim( esconderAno ) or not ano ) and trim( esconderMes ) and true or nil,
        -- or nil serve apenas para evitar arrastar um valor falso em todos os testes unitários.
    }
    else
    return true, {}
    end
end


---
-- validationDiaMesAno verifica os parâmetros correspondentes a uma cadeia valida de dados.
-- os dados podem estar nos parâmetros 1 a 3, ou nos parâmetros dia, mes e ano.
-- A função retorna true seguida por uma tabela com os dados em parâmetros nomeados (sem foco no ano)
-- ou falso seguido por uma mensagem de erro.
function fun.validationDiaMesAno( frame, ... )
    local args = Ferramentas.extractArgs( frame, ... )
    local dia, mes, numMes, ano
    local bdia = args[1] or args['dia'] or ''
    local bmes = tostring( args[2] or args['mês'] or args['mes'] or '' )
    local bano = args[3] or args['ano'] or args['year'] or ''
 
    local function erro( periode, valor )
    return false, '<span class="error">' .. periode .. ' inválido (' .. valor .. ')</span>'
    end
 
    -- agora tratamos o ano
    if Ferramentas.notEmpty( bano ) then
    ano = tonumber( bano )
    if ano == nil and type( bano ) == 'string'  then
        -- teste se o ano contiver a.C.
        ano = string.match( string.upper( bano ), '^(%d+) ?[Aa]%.? ?[Cc]%.?' )
        ano = tonumber( ano )
        if ano then
        ano = 0 - ano
        else
        return erro( 'Ano', bano )
        end
    elseif ano == 0 then
        return erro( 'Ano', 0 )
    end
    else
    ano = nil
    end
 
    -- agora tratamos o mês
    if Ferramentas.notEmpty( bmes ) then
    mes, numMes = fun.determinationMes( bmes )
    if mes == nil then
        mes = fun.validaEstacao( bmes )
        if mes == nil then
        return erro( 'Mês', bmes )
        end
    else   
        -- agora tratamos o dias se está informado
        if Ferramentas.notEmpty( bdia ) then
        dia = tonumber( bdia )
        if dia == nil then
            dia = tonumber( fun.limpezaDia( bdia ) )
        end
        if dia == nil then
            return erro( 'Dia', bdia )
        end
        -- agora verifica se dia está bem
        if dia < 1 or dia > 31 then
            return erro( 'Dia', bdia )
        elseif dia > listaMes[numMes].nDia then
            return erro( 'Dia', bdia .. ' ' .. mes )
        elseif dia == 29 and numMes == 2 and ano and ( math.fmod( ano, 4 ) ~= 0 ) then
            --o ano bisexto nos séculos é de todos os dias aceite para ser compatível com dados julianos.
            return erro( 'Dia', '29 de fevereiro de ' .. ano     )
        end
        else
        -- Se não houver dia, a pessoa olha se a primeira letra do mes é minuúscula
        if bmes:match( '^%u' ) then
            -- sim, passamos a primeira letra em letras minúsculas
--              mes = lcfirst( mes )
        end
        -- se não houver ano, retornamos o mês simples
        end
    end
    else
    -- verificamos o dia se está informado
    if Ferramentas.notEmpty( bdia ) then
        if ano then
        return erro( 'Mês', 'não informado' )
        else
        bdia = fun.limpezaDia( bdia )
        dia = tonumber( bdia )
        if dia then
            if dia > 31 or dia < 1 then
            ano = dia
            dia = nil
            else
            return erro( 'Data', 'dia único : ' .. bdia )
            end
        else
            return erro( 'Dia', bdia )
        end
        end
    end
    end
 
    -- verificação da ausência de desvio
    if ano and ano < 13 and ano > 0 and not dia and ( tonumber( bmes ) or (not mes and tonumber( args[4] ) ) ) then
    return false, '<span class="error">ano improvável (' .. ano .. ')</span>'
    end
   
    local resultado = {
    dia = dia,
    mes = mes,
    numMes = numMes,
    ano = ano,
    esconderAno = args.esconderano,
    esconderMes = args.escondermes,
    }
    return true, resultado
end


---
-- emula a predefinição {{tl|Data}}.
-- Configurações:
-- 1: dia (número) ou os dados completos
-- 2: mês (na íntegra) ou estação do ano
-- 3: ano (número)
-- 4: estação do ano
-- juliano: dados no calendário juliano
-- compacto: exibe o mês como uma abreviatura
-- ad: não para desativar a exibição de "a.C." para dados negativos
-- idade: adicione a duração desde que esses dados
-- nolink: não coloque um link nos dados
-- nascimento: adicione a classe "bday"
-- dead: adicione a classe "dday"
function fun.modeloData( frame )
    local args = Ferramentas.extractArgs( frame )
    local cat, resultado = ''
 
    -- analisar parâmetros sem nome (ou parâmetros de dados dia, mês, ano)
    local test, params
    local arg1, arg2, arg3 = fun.limpezaDia( args[1] ), trim( args[2] ), trim( args[3] )
    if type( arg1 ) == 'string' and arg3 == nil and ( arg1:match( '[^ ./-][ ./-]+[^ ./-]' ) or arg2 == nil or dataLinks[arg2] or mw.ustring.match( arg2, '%a %a' ) ) then
    -- os dados estão no primeiro parâmetro
    test, params = fun.separationDiaMesAno( arg1 )
    if test then
        params.qualificativo = arg2
    end
    else
    local function esconderParam( p )
        -- separa o possível sinal de menos significando que o parâmetro não deve ser exibido.
        if type( p ) ~= 'string' then
        return p, nil
        end
        local value, mask = p:match( '^%s*(.-)(%-?)%s*$' )
        return value, ( mask == '-' or nil )
    end
    local cleanArgs = { arg1 or args.dia }
    cleanArgs[2], cleanArgs.escondermes = esconderParam( args[2] or args.mes )
    cleanArgs[3], cleanArgs.esconderano = esconderParam( args[3] or args.ano )
   
    test, params = fun.validationDiaMesAno( cleanArgs )
    if test then
        params.qualificativo = trim( args[4] )
    end
    end
 
    -- analisar os parâmetros nomeados
    if test then
    local Yesno = require 'Módulo:Yesno'
    params.qualificativo = params.qualificativo or args.qualificativo
    -- Juliano pode ter três valores: inativo, formato padrão (true), formato curto
    params.juliano = Yesno( args.juliano, 'curto', false )
    params.ac = Yesno( args.ac )
       
    local listaParam = {
        idade = 'idade',
        nascimento = 'nascimento',
        morte = 'morte',
        falecido = 'morte',
        ac = 'a.C.',
        nolinks = 'nolinks',
        compacto = 'compacto',
        compacta = 'compacto',
    }
    for n, v in pairs( listaParam ) do
        params[v] = params[v] or Yesno( args[n], true, false ) or nil
    end
   
    -- saída para testes unitários ou para depurar
    if args.debug then
        return params
    end
   
    resultado = fun._modeloData( params )

    else
    local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
    if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] and not Ferramentas.notEmpty( args.nocat ) then
        cat = '[[Categoria:!Páginas que usam a predefinição data com erros de sintaxe]]'
    end
    resultado = params .. cat
    end
 
    return resultado or ''
end

function fun._modeloData( args )
    local ano, mes, numMes, dia = args.ano, args.mes, args.numMes, args.dia
    local qualificativo = args.qualificativo
 
    if ( ano or mes or dia ) == nil then
    return
    end
 
    -- agora tratamos a idade, o nascimento e a morte
    local idade = args['idade'] and  fun.idade( ano, numMes, dia )
    local nascimento = args.nascimento
    local morte = args.morte
 
    -- tratar o calendário
    local gano, gmes, gdia = ano, numMes, dia    -- dados de acordo com o calendário gregoriano para <hora>
    local jano, jmes, jdia = ano, mes, dia      -- dados de acordo com o calendário juliano, se necessário
    local julianoData, julianoSup, julianoSep         -- pode ser usado para exibir os dados de acordo com o calendário juliano
    local gregAprMes, gregAprAno, gregFim       -- Mensagem do calendário gregoriano quando os dados estão de acordo com o calendário juliano
    if ano and dia then
    local amj = ano * 10000 + numMes * 100 + dia
    if amj < 15821014 then
        if ano > 0 then
           gano, gmes, gdia = fun.julianToGregorian( ano, numMes, dia )
        else
       -- Calendário gregoriano proléptico com ano 0.
           gano, gmes, gdia = fun.julianToGregorian( ano + 1, numMes, dia )
        end
        args.juliano = false
   
    elseif args.juliano then
        gano, gmes, gdia = fun.julianToGregorian( ano, numMes, dia )
        ano, mes, dia = gano, listaMes[gmes].nome, gdia
        if args.compacto then
           jmes = listaMes[ jmes ].abrev
        end
        if args.juliano == 'curto' then
           julianoData = jdia .. ' ' .. jmes .. ' '
           julianoSup = '<sup>[[calendário juliano|jul.]]</sup>'
           if jano == ano then
              gregAprMes = '<sup>[[calendário gregoriano|greg.]]</sup>'
           else
              julianoData = julianoData .. jano .. ' '
              gregAprAno = '<sup>[[calendário gregoriano|greg.]]</sup>'
           end
           julianoSep = ' / '
        else
           julianoData = jdia .. ' ' .. jmes .. ' ' .. jano
           julianoSep = ' ('
           gregFim = ' [[Mudança para o calendário gregoriano|dentro do calendário gregoriano]])'
        end
    end
    else
       if ano and ano < 0 then
          gano = gano + 1
       end
       args.juliano = false
 
    end
 
    -- agora geramos o resultado
 
    -- Declarações de variáveis
    local wikiLista = {}           -- recebe a mensagem de texto exibida para cada parâmetro
    local iso = {}             -- recebe o formato de data ISO de cada parâmetro
    local textoMes = mes         -- mensagem de texto que será exibida (possivelmente a abreviação)
    if args.compacto then
       if args.nolinks then
             textoMes = '<abbr class=abbr title="' .. mes .. '">' .. listaMes[ mes ].abrev .. '</abbr>'
       else
      textoMes = listaMes[ mes ].abrev
       end
    end
 
    local dataQualificativo, dataCat
    if not args.nolinks then
    dataQualificativo = dataLinks[qualificativo or '']
    if type( dataQualificativo ) ~= 'table' then
        -- se o qualificador não estiver no banco de dados, criamos uma tabela mínima,
        -- que vai impor um teste no ano, mas considera que não há link no dia ou no mes
        dataQualificativo = { qualificativo = ' ' .. qualificativo, ano = { } }
    end
    dataCat = dataLinks[dataQualificativo.cat]
    if type( dataCat ) ~= 'table' or dataCat == dataQualificativo then
        dataCat = { qualificativo = '' }
    end
    end
    local function wikiLink( link, texto )
    if link == texto then
        return '[[' .. texto .. ']]'
    else
        return '[[' .. link .. '|' .. texto .. ']]'
    end
    end
 

    -- o dia se informado
    local qualifDia = ''
    if dia then
    local textoDia = dia
    if args.nolinks then
        table.insert( wikiLista,  dia )
    else
        qualifDia = dataQualificativo.dia and dataQualificativo.qualificativo
        or dataCat.dia and dataCat.qualificativo
        or ''
        local link = dia .. ' de ' .. mes .. ' ' .. qualifDia
        -- se não houver um link no mes, ele será exibido com o dia.
        table.insert( wikiLista,  wikiLink( link, dia ) )
        table.insert( wikiLista,  wikiLink( link, dia .. ' de '.. textoMes ) )
    end
    table.insert( iso,  1, string.sub( '0' .. gdia, -2 ) )
    end
 
    -- o mês
    if mes then
    if #wikiLista == 0 and ano == nil then
        return textoMes
    end
    if args.nolinks then
        if not args.escondermes then
        table.insert( wikiLista,  textoMes )
        end
    else
        local link
        if ano then
        link = existData( dataQualificativo, ano, mes ) or existData( dataCat, ano, mes )
        if link == nil and qualificativo and qualifDia == '' then
            -- teste novo teste sem o qualificador somente se não houver efemérides para esse qualificador.
            link = existData( dataLinks[''], ano, mes )
        end
        end
        if link or args.escondermes then
        -- se houver um link, remova o link que exibe 'dia mes' para adicionar 'Mês dia'
        table.remove( wikiLista )
        if not args.escondermes then
            table.insert( wikiLista,  wikiLink( link, textoMes ) )
        end
        elseif #wikiLista > 0 then
        -- caso contrário, removemos o link exibindo 'dia' para manter apenas o link 'dia mês'
        table.remove( wikiLista, #wikiLista - 1 )
        elseif args.esconderano then
        -- se não houver dia e o ano não for exibido, insira o único.
        table.insert( wikiLista,  textoMes )
        end
    end
    if gmes then
        table.insert( iso,    1, string.sub( '0' .. gmes, -2 ) )
        table.insert( wikiLista, ' de ' )
    end
    table.insert( wikiLista, gregAprMes )
    end
 
    -- o ano
    if ano and not (args.juliano == true and args.nolinks and jano == ano ) then
    if not args.esconderano then
        local textoAno = ano
        local link
        if ano < 0 then
        local anoaC = 0 - ano
        link = link or ( anoaC .. ' a.C.' )
        if args.ac == false then
            textoAno = anoaC
        else
            textoAno = anoaC .. ' <abbr class="abbr" title="'
            .. anoaC .. ' antes da Era Comum">a.C.</abbr>'
        end
        elseif args.ac then
        textoAno = textoAno .. ' <abbr class="abbr" title="'
            .. textoAno .. ' depois da Era Comum">depois de a.C.</abbr>'
        end
        if args.nolinks then -- somente se tivermos que exibi-lo
        table.insert( wikiLista,  textoAno )
        else
        link = existData( dataQualificativo, ano ) or existData( dataCat, ano ) or link or ano      
        if mes and #wikiLista == 0 then
            -- se o mes não tiver link e não for exibido com o dia, ele será exibido com o ano.
            textoAno = textoMes .. ' de ' .. textoAno
        end
        table.insert( wikiLista,  wikiLink( link, textoAno ) )
        end
    end
    end
    if ano then
       if gano > 999 then
             table.insert( iso,    1, gano )
       elseif gano > -1 then
             table.insert( iso,    1, string.sub( '000' .. gano , -4 ) )
       elseif gano > -999 then
           -- Calendário gregoriano proléptico com ano 0.
          table.insert( iso,    1, 'U-' .. string.sub( '000' .. ( 0 - gano ), -4 ) )
       else
          table.insert( iso,    1, 'U' .. gano )       
       end
    end
    table.insert( wikiLista, gregAprAno )

    -- a idade
    if type( idade ) == 'number' and idade >= 0 and ( not nascimento or idade < 120 ) then
    if idade == 0 then
        idade = '(menos de um ano)'
    elseif idade == 1 then
        idade = '(1 ano)'
    else
        idade = '(' .. idade .. ' anos)'
    end
    else
    idade = false
    end
 
 
    -- compilação dos resultados
    local wikiTexto = table.concat( wikiLista, ' ' )
    local isoTexto = table.concat( iso, '-' )
 
    -- Nós adicionamos um pouco de semântica.
    local wikiHtml = mw.html.create( '' )
 
    if julianoData then
    wikiHtml:tag( 'span')
        :addClass( 'nowrap' )
        :attr( 'date-sort-value', isoTexto )
        :wikitext( julianoData    )
        :node( julianoSup )
        :done()
        :wikitext( julianoSep )
    end
 
    local dataHtml = wikiHtml:tag( 'time' )
        :wikitext( wikiTexto )
    if wikiTexto:match( ' ' ) then
    dataHtml:addClass( 'nowrap' )
    end
    if isoTexto ~= wikiTexto then
    dataHtml:attr( 'datetime', isoTexto )
        :attr( 'date-sort-value', isoTexto )
    end
    if not args.nolinks then
    dataHtml:addClass( 'date-link' )
    end
    if nascimento then
    dataHtml:addClass( 'bday' )
    elseif morte then
    dataHtml:addClass( 'dday' )
    end
 
    wikiHtml:wikitext( gregFim )
 
    if idade then
    wikiHtml:wikitext( ' ' )
        :tag( 'span' )
            :addClass( 'noprint')
            :wikitext( idade )
            :done()
    end
 
    return tostring( wikiHtml )
end


---
-- função para infoboxes, especialmente para exibir nascimento e dados mortos
-- os links presentes nos dados fornecidos são automaticamente excluídos para gerenciar os casos ou
-- o parâmetro já contém um modelo de dados.
-- Configurações:
--      1 : type de dados a afixar (nascimento / n, morte / m, ou data / d)
--      1 : Data ou data de nascimento
--      2 : Data de morte se tipo n ou m
--      qualificativo = sufixo de páginas de dados para vincular (exemplo: na música)
--      nolinks : não mostrar link
--      préfixe : prefixo para exibir se houver um dia (por padrão '')
--      prefixo sem dia: prefixo a ser exibido se não houver dia (padrão: '')
function fun.dataInfobox( frame )
    local args = frame.args
    if type( args ) ~= 'table' or not ( args[1] and args[2] ) then
    return
    end
 
    -- analisarData separa os dados do conteúdo a seguir, exclui os links e, se possível, retorna uma tabela com os anos
    local function analisarData( d )
    if trim( d ) then
        local analisar = d:match( ' ou ') or d:match( 'entre ' ) or d:match( 'para ' ) or d:match( 'depois ' ) or d:match( 'antes ' )
        if analisar then
        return d
        end
        analisar = d:match( 'datetime="([%d-]+)"' ) or d
        -- separa os dados (com seus links) de uma referência ou conteúdo que começa com um espaço)
        local inicio, fim = analisar:match( '(.-%d%d%d%]*%-?)([\127 ].+)' )
        if not inicio then
        -- separa os dados do conteúdo começando com <br>
        inicio, fim = analisar:match( '(.-%d%d%d%]*%-?)(<br ?/?>.+)' )
        end
        analisar = inicio or analisar
        -- excluir links
        analisar = analisar:gsub(
        '%[%[([^%[%]|]*)|?([^%[%]]*)%]%]',
        function ( l, t )
            return trim( t ) or l
        end
        )
        local t, r = fun.separationDiaMesAno( analisar )
        if t then
        return r, fim
        else
        return d, fim
        end
    end
    end
    -- prefixo adiciona um prefixo dependendo da presença ou ausência do dia se o parâmetro "prefixo sem dia" for definido
    local function prefix( dataString )
    if dataString then
        local datetime = dataString:match( 'datetime="([U%d%-]+)"' )
        if datetime and datetime:match('%-%d%d%-%d%d') and trim( args['prefixo'] ) then
        return args['prefixo'] .. ' ' .. dataString
        end
        if trim( args['prefixo sem dia'] ) then
        return args['prefixo sem dia'] .. ' ' .. dataString
        end
    end
    return dataString
    end
 
    local nascimento = args[1]:match( '^n' ) == 'n'
    local morte = args[1]:match( '^m' ) or args[1]:match( 'morte' )
    local mostrarData, qualificativo = args[2], args[4]
    local mostrarDataTab, resultadoData, complementData
    local dataNascimento, dataMorte
    if morte then
    mostrarData = args[3]
    end
    if not trim( mostrarData ) then
    return
    end
    if mostrarData:match( '</time>' ) then
    -- Se houver links, provavelmente já existe um modelo de dados, evite executá-lo uma segunda vez
    if ( nascimento or morte ) and ( mostrarData:match( 'wikidata%-linkback' ))  then
        dataNascimento = analisarData( args[2] )
        dataMorte = analisarData( args[3] )
        resultadoData = mostrarData
    else
        return prefix( mostrarData )
    end
    else
    mostrarDataTab, complementData = analisarData( mostrarData )
    if type( mostrarDataTab ) ~= 'table' then
        return mostrarDataTab
    else
        if nascimento then
        dataNascimento = mostrarDataTab
        dataMorte = analisarData( args[3] )
        elseif morte then
        dataNascimento = analisarData( args[2] )
        dataMorte = mostrarDataTab
        else
        qualificativo = args[3]
        end
        mostrarDataTab.nascimento = nascimento
        mostrarDataTab.morte = morte
        mostrarDataTab.qualificativo = args.qualificativo or qualificativo
        mostrarDataTab.nolinks = args.nolinks
        mostrarDataTab.nocat = args.nocat
        mostrarDataTab.juliano = args.juliano
    end
    end
    resultadoData = resultadoData or fun.modeloData( mostrarDataTab )
 
    local idade, prefixIdade, suffixIdade, calculoIdade = '', ' <span class="noprint">(', ')</span>', nil
    if nascimento and
    dataNascimento and
    not dataMorte and
    type( dataNascimento ) == 'table'
    then
    calculoIdade = fun.idade( dataNascimento.ano, dataNascimento.numMes, dataNascimento.dia )
    if calculoIdade and calculoIdade > 120 then
        calculoIdade = nil
    end
    elseif morte and
    dataNascimento and
    dataMorte and
    type( dataNascimento ) == 'table'
    and type( dataMorte ) == 'table'
    then
    calculoIdade = fun.idade(
        dataNascimento.ano,
        dataNascimento.numMes,
        dataNascimento.dia,
        dataMorte.ano,
        dataMorte.numMes,
        dataMorte.dia
    )
    prefixIdade = ' (a '
    suffixIdade = ')'
    end
    if tonumber( calculoIdade ) then
    if calculoIdade > 1 then
        idade = prefixIdade .. calculoIdade .. ' anos' .. suffixIdade
    elseif calculoIdade == 1 then
        idade = prefixIdade .. 'um ano' .. suffixIdade
    elseif calculoIdade == 0 then
        idade = prefixIdade .. 'menos de um ano' .. suffixIdade
    end
    if complementData and complementData:match( 'anos?%)' ) then
        complementData = ''
    end
    end
 
    return prefix( resultadoData ) .. ( complementData or '' ) .. idade
end


---
-- a função dataISO retorna um dado no formato aaaa-mm-dd (sem links)
-- o ano pode ser na forma 2013 ou [[2013 na literatura|2013]]
-- o mês pode estar em letra ou em número
-- o dia pode estar no formato '5',  ou 'Sexta 13'

function fun.dataISO( frame )
    local args = Ferramentas.extractArgs( frame )
    local ano = Ferramentas.notEmpty( args.ano, args.year, args.data )
    -- extração do ano
    if type( ano ) == 'string' then
    ano = ( tonumber( ano )       -- match '2013'
        or string.match ( ano, '%D(%d%d%d%d)%D' ) -- match  '[[2013 na música|2013]]'
        or string.match ( ano, '%D(%d%d%d%d)%D$' )  -- match '17 de setembro de 2013'
        or string.match ( ano, '^(%d%d%d%d)%D' )  -- match '2013-09-17'
    )
    end
    ano = tonumber( ano )
 
    -- O formato iso de dados é definido de acordo com o calendário gregoriano.
    -- Antes do ano de 1583 os dados são calendários é provavelmente do calendário juliano,
    -- então se abstenha.
    if ano and ano > 1582  then
    local mes = Ferramentas.notEmpty( args.mes, args.month )
    -- num mês encontra o número de mês, seja númerico ou texto, completo ou abreviado.
    local nomeMes, numMes = fun.determinationMes( mes )
    if numMes then
        mes = '-' .. string.sub( '0' .. numMes, -2 )
   
        local dia = Ferramentas.notEmpty( args.dia, args.day, args['calendário'] )
        if type( dia ) == 'string' then
        dia = tonumber( dia ) or tonumber( string.match ( dia, '%d+') )
        end
        dia = tonumber( dia )
        if dia and dia <= listaMes[numMes].nDia then
        dia = '-' .. string.sub( '0' .. dia, -2 )
        return ano .. mes .. dia
        else
        return ano .. mes
        end
    else
        return tostring( ano )
    end
    end
end

---
-- Rank do dia no ano
-- Uso: do_dayRank {ano, meu, dia}
function fun.do_dayRank(arguments)
    local yr = tonumber(arguments.year or arguments[1]) or 1
    local mt = tonumber(arguments.month or arguments[2]) or 1
    local dy = tonumber(arguments.day or arguments[3]) or 1
    -- Classificações do primeiro do mês
    local ranks = {0,31,59,90,120,151,181,212,243,273,304,334}
 
    local rank = (ranks[mt] or 0) + dy - 1
    if(fun.isLeapYear(yr) and (mt >= 3)) then
    rank = rank+1
    end
    return rank
end

-- Número de dias entre dois anos (de 1 de janeiro a 1 de janeiro)
-- Segue o calendário gregoriano
function fun.do_daysBetween(arguments)
    local yr1 = tonumber(arguments[1]) or 0
    local yr2 = tonumber(arguments[2]) or 0
 
    return fun.daysSinceOrigin(yr2) - fun.daysSinceOrigin(yr1)
end

-- Número de dias desde o ano 1 (de 1 de janeiro a 1 de janeiro)
function fun.daysSinceOrigin(year)
    local yr = year-1
    return 365*yr + math.floor(yr/4) - math.floor(yr/100) + math.floor(yr/400)
end

-- Teste do ano bissexto (segue o calendário gregoriano)
function fun.isLeapYear(year)
    local yr = tonumber(year) or 1
    return (yr%4 == 0) and ((yr%100 ~= 0) or (yr%400 == 0))
end

-- Convertendo um número em algarismos romanos
function fun.toRoman(number)
    local n = math.floor(number)
    local letters = {"I","V","X","L","C","D","M","",""}
    local pattern = {"","0","00","000","01","1","10","100","1000","02"}
    local result = ""
    if(n<=0 or n>=4000) then
    result = "---"
    else
    for i=1,7,2 do
        local p = pattern[n%10 + 1]
        for j=0,2 do
        p = string.gsub(p,tostring(j),letters[i+j])
        end
        result = p .. result
        n = math.floor(n/10)
    end
    end
    return result
end

---
-- Calculando um dado no calendário republicano
-- Supõe-se que os anos 4n + 3 são mais sextiles (3, 7, 11 ...)
function fun.do_toRepCal(arguments)
    local yr = tonumber(arguments.year or arguments[1]) or 2000
    -- gama absoluto do dia solicitado, sendo o dia 0 ou 22 de setembro de 1792 (1º dia do ano I)
    local repDays = fun.do_dayRank(arguments) + fun.do_daysBetween{1792,yr} - fun.do_dayRank{1792,9,22}
    local repYear = math.floor((repDays+731)/365.25) - 1
    local repDayRank = repDays - 365*(repYear-1) - math.floor(repYear/4)
    local repMonth, repDay = math.floor(repDayRank/30)+1, (repDayRank%30)+1
    return {repYear, repMonth, repDay}
end

---
-- Ver Predefinição:Idade
-- retorna a idade de acordo com os dados fornecidos. O valor retornado é do tipo 'número'
-- Parâmetros:
-- 1, 2, 3: ano, mês dia de nascimento (suposto no calendário gregoriano)
-- 4, 5, 6: year, mês, dia do cálculo (opcional, por padrão, os dados UTC atuais).
function fun.idade( an, mn, jn, ac, mc, jc )
    if ac == nil then
    local today = os.date( '!*t' )
    ac = today.year
    mc = today.month
    jc = today.day
    else
    ac = tonumber( ac )
    mc = tonumber( mc )
    jc = tonumber( jc )
    end

    local an = tonumber( an )
    local mn = tonumber( mn )
    local jn = tonumber( jn )

    if an == nil or ac == nil or mn == nil or mc == nil then
    -- nenhuma mensagem de erro que possa travar a função de chamada
    -- para ela gerenciar esse retorno.
    return
    end
 
    local idade = ac - an
    if mc == mn then
    if jc == nil or jn == nil then
        return
    end
    return idade-tonumber( jc < jn and 1 or 0 )
    else
    return idade-tonumber( mc < mn and 1 or 0 )
    end
end

function fun.modeloIdade( frame )
    local args = frame.getParent().args
    local idade = fun.idade (
    args[1] or args['ano'],
    args[2] or args['mês'] or args['mes'],
    args[3] or args['dia'],
    args[4],
    args[5],
    args[6]
    )
    if idade then
    return idade
    else
    return '<span class="error">Parâmetro incorretos ou insuficientes para calcular a precisão da idade</span>'
    end
end

---
-- calcula o dia juliano à partir de uma data do calendário gregoriano
function fun.julianDay( year, month, day, hour, min, sec )
    local julian
    julian = math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) * 1461 / 4 )
        - math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) / 100 )
        + math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) / 400 )
        + math.floor( ( math.fmod( month + 57609, 12 ) + 4 ) * 153 / 5 )
        + day + ( hour or 12 ) / 24 + ( min or 0 ) / 1440 + ( sec or 0 ) / 86400
        - 32167.5
    return julian
end

---
-- cálculo do dia juliano a partir de um dado do calendário juliano
function fun.julianDayJulian( year, month, day, hour, min, sec )
    local julian
    julian = math.floor( math.floor( ( year * 12 + month + 57609 ) / 12 - 1 ) * 1461 / 4 )
        + math.floor( ( math.fmod( month + 57609, 12 ) + 4 ) * 153 / 5 )
        + day + ( hour or 12 ) / 24 + ( min or 0 ) / 1440 + ( sec or 0 ) / 86400
        - 32205.5
    return julian
end

---
-- cálculo de um dado no calendário gregoriano do dia juliano
function fun.julianDayToGregorian( julianDay )
    local base = math.floor( julianDay + 32044.5 )    -- 1 March -4800 (proleptic Gregorian data)
    local nCentury = math.floor( ( base * 4 + 3 ) / 146097 )
    local sinceCentury = base - math.floor( nCentury * 146097 / 4 )
    local nYear = math.floor( ( sinceCentury * 4 + 3 ) / 1461 )
    local sinceYear = sinceCentury - math.floor( nYear * 1461 / 4 )
    local nMonth = math.floor( ( sinceYear * 5 + 2 ) / 153 )
 
    local day = sinceYear - math.floor( (  nMonth  * 153 + 2 ) / 5 ) + 1
    local month = nMonth  - math.floor(     nMonth     / 10 ) * 12 + 3
    local year = math.floor( sinceYear / 306 ) + nYear + 100 * nCentury - 4800
 
    return year, month, day
end

---
-- cálculo de um dado no calendário juliano do dia juliano
function fun.julianDayToJulian( julianDay )
    local year = math.modf( ( julianDay * 4 - 6884469 ) / 1461 )
    local r2 = julianDay - math.modf( ( 1461 * year + 6884472 ) / 4 )
    local month = math.modf( ( 5 * r2 + 461 ) / 153 )
    local day = r2 - math.modf( ( 153 * month - 457 ) / 5 ) + 1
    if month > 12 then
    year = year + 1
    month = month - 12
    end
    return year, month, day
end

---
-- cálculo de um dado no calendário gregoriano a partir de um dado no calendário juliano
function fun.julianToGregorian( year, month, day )
    return fun.julianDayToGregorian( fun.julianDayJulian( year, month, day ) )
end

---
-- cálculo de um dado no calendário juliano a partir de um dado no calendário gregoriano
function fun.gregorianToJulian( year, month, day )
    year = tonumber(year)
    if month then month = tonumber(month) else month = 6 end --leva um valor central para dar um melhor "palpite"
    if day then day = tonumber(day) else day = 15 end
    return fun.julianDayToJulian( fun.julianDay( year, month, day ) )
end


--[[
  Esta função devolve "CET" ou "CEST" dependendo se no pseudo timezone atual
     é hora de verão ou inverno.
   Esta função só faz sentido para predefinições usados na Europa
 
   Parâmetro opcional sem nome: "sem link": retorna o texto CET / CEST. caso contrário
     retornar o mesmo texto com um wikilink para os artigos correspondentes
--]]
function fun.CEST(frame)
    -- opção : não crie wikilink
    local opt = trim(frame.args[1] or frame:getParent().args[1])
    -- recuperamos as informações na zona atual
    local t = mw.getContentLanguage():formatDate("I", nil, true)
 
    if (t == "1") then    -- hora de Verão
    if (opt == "sem link") then
        return "CEST"
    elseif (opt == "desvio") then
        return "2"
    else
        return "[[Horário de Verão da Europa Central|CEST]]"
    end
    else  -- horário de inverno (ou outra área onde não se aplica)
    if (opt == "sem link") then
        return "CET"
    elseif (opt == "desvio") then
        return "1"
    else
        return "[[Horário da Europa Central|CET]]"
    end
    end
end

return fun