"Modül:Kategori" sayfasını değiştirmektesiniz


--Genel veriler

local degerler = {"kurulan", "feshedilen", "feshedilmiş", "kapanan", "kapatılan", "varlığı sona eren",
	"başlayan", "sona eren", "tamamlanan", "tamamlanmış", "tanıtılan", "tanıtılmış", "tanımlanan",
	"verilen", "doğan", "doğumlu", "ölen", "keşfedilen", "fırlatılan", "geçen", "yapan", "açılan",
	"oluşturulan", "kurulmuş", "başlatılan"
}

--lazım olabilecek kademe listesi
local kademeler = {"yıl", "onyıl", "yüzyıl", "binyıl"}

--onu ikinci değer ile değiştirmeye yarar
local function bulvedeg(yazi, bir, iki)
	return mw.ustring.sub(mw.ustring.gsub(yazi, bir, iki), 1, -1)
end

--yerelde kod kısaltmak için
local bul = mw.ustring.find

--tarih tarih
local tarih = require("Modül:Tarih")
local function yilBul(p1, p2) return tarih.YIL({args={p1, p2}}) end
-- bu fonksiyonun sonucu "2020'ler" gibi olur
local function onYil(p1, p2) return tarih.ONYIL({args={p1, p2}}) end
-- bu fonksiyonun sonucu "21. yüzyıl" gibi olur
local function yuzYil(p1, p2) return tarih.YUZYIL({args={p1, p2}}) end
-- bu fonksiyonun sonucu "3. binyıl" gibi olur
local function binYil(p1, p2, p3) return tarih.BINYIL({args={p1, p2, p3 or "yüzyıl"}}) end

-- tipe göre ikinci tablodaki değerleri verir
local function tipeGorePar(tip, tab)
	if tip == "yıl" then return tab[1]
	elseif tip == "onyıl" then return tab[2]
	elseif tip == "yüzyıl" then return tab[3]
	elseif tip == "binyıl" then return tab[4] end
end

local function siralamaSapta(deger, tip)
	return tipeGorePar(tip, {
		bulvedeg(deger, "MÖ ", "-"),
		bulvedeg(bulvedeg(onYil(deger), "'l[ae]r", ""), "MÖ ", "-"),
		bulvedeg(bulvedeg(yuzYil(deger), ". yüzyıl", ""), "MÖ ", "-"),
		bulvedeg(bulvedeg(binYil(deger, 0, "yıl"), ". binyıl", ""), "MÖ ", "-")
	})
end

---*---*---*---*---*---*---*---*---*---*---*---*---
-- kategori nesnesini ilgilendiren
-- fonksiyon ve tablolar
---*---*---*---*---*---*---*---*---*---*---*---*---
local Kategori = {}


function Kategori:getirAsilAd(kademe)
	return tipeGorePar((kademe and kademe or self._tip), self._rawData) or self._asilAd
end


function Kategori:getirKategoriAdi(goreTipi)
	local yil = self:getirYil()
	local ad = self:getirAsilAd()
	
	local function mevcutMu(yil, ad)
		-- yıl ifadesinden önce gelen bir ifade mevcut mu?
		if self:basta() then
			if type(self:basta()) == "table" then
				ad = bulvedeg(ad, tipeGorePar(self._tip, self:basta()), "")
				yil = tipeGorePar(self._tip, self:basta()) .. " " .. yil
			else
				ad = bulvedeg(ad, self:basta(), "")
				yil = self:basta() .. " " .. yil
			end
		end
		
		local d1, d2 = yil, ad
		return mw.title.new('Kategori:' .. d1 .. d2).exists and d1 .. d2 or d1 .. " " .. d2
	end
	
	local k = type(self._rawData.ek) == "table"
	local yEk = k and self._rawData.ek[1] or self._rawData.ek
	local oEk = k and self._rawData.ek[2] or yEk
	local uEk = k and self._rawData.ek[3] or oEk
	local bEk = k and self._rawData.ek[4] or uEk

	local ek = tipeGorePar(self:getirTip(), {yEk, oEk, uEk, bEk})
	
	-- göre kategorileri için
	if self:getirTip() == "göre" and not bul(self._yil, "%d") then
		local son
		local ust = self:sonHarfSil()
		local gore = self:gore()
		
		if goreTipi then
			local hey = goreTipi .. " göre " .. self:sonHarfSil()
			if mw.title.new("Kategori:" .. tipHallet(hey, self._yil)).exists
			and not mw.title.new("Kategori:" .. tipHallet(hey, self._yil)).isRedirect then
				ust = hey
			end
		end

		if self._yil == "dönem" and self:gore() == "üst" then
			for _,d in ipairs(degerler) do
				ust = bulvedeg(ust, "^"..d.."%s", "") or ust
			end
			son = ust
		else
			local normal = tipHallet(ust, self._yil)
			if self._yil == "dönem" then
				son = (type(gore) == "string" and gore ~= "hayır") and self:gore() or normal
				son = type(self:gore()) == "table" and self:gore()[2] or normal
			else
				son = normal
			end
		end
		return son
	elseif yil then
		if ek and ek ~= "d" and ek ~= "y" then
			if ek == "ki" then
				return mevcutMu(yilEki(yil)..ek, ad)
			elseif type(ek) == "table" then
				for _,x in ipairs(ek) do
					if mw.title.new('Kategori:' .. mevcutMu(yil..x, ad)).exists then
						return mevcutMu(yil..x, ad)
					end
				end
			else
				return mevcutMu(yil..ek, ad)
			end
		elseif ek and ek == "d" then
			return mevcutMu(yilEki(yil), ad)
		else
			return mevcutMu(yil, ad)
		end
	else
		return ad
	end
end


function Kategori:getirCubukAdi()
	return tipeGorePar(self._tip, {
		yilBul(self._yil), self._yil,
		bulvedeg(self._yil, "yüzyıl", "yy"), bulvedeg(self._yil, "binyıl", "by")
	})
end


function Kategori:getirYil()
	return tipeGorePar(self._tip, {
		yilBul(self._yil), onYil(self._yil),
		yilBul(self._yil)..". yüzyıl", yilBul(self._yil)..". binyıl"
	})
end


function Kategori:gore()
	return self._rawData.gore
end


function Kategori:goreSon()
	return self._rawData.goreSon
end


function Kategori:goreTipi()
	return self._rawData.goreTipi
end


function Kategori:basta()
	return self._rawData.basta
end


function Kategori:donustur()
	return self._rawData.donustur
end


function Kategori:kademe()
	return self._rawData.kademe
end


function Kategori:kademeYok()
	local kademeyiSil
	local tip = self._tip
	local kademeYok = self._rawData.kademeYok
	
	if kademeYok then
		if kademeYok == 3 then
			if tip == "yıl" or tip == "onyıl" or tip == "yüzyıl" then
				kademeyiSil = true
			end
		elseif kademeYok == 2 then
			if tip == "yıl" or tip == "onyıl" then
				kademeyiSil = true
			end
		elseif kademeYok == 1 then
			if tip == "yıl" then
				kademeyiSil = true
			end
		end
	end
	
	return kademeyiSil
end


function Kategori:getirYoksa()
	local yoksa = self._rawData.yoksa or nil
	local yoksaYil = yoksa and siralamaSapta(yoksa[1], self._tip) or nil
	local yil = bulvedeg(bulvedeg(self._yil, "'l[ae]r", ""), "MÖ ", "-")
	yil = bulvedeg(yil, ". yüzyıl", "")
	yil = bulvedeg(yil, ". binyıl", "")
	
	if yoksa and yoksaYil and yil and tonumber(yil) < tonumber(yoksaYil) then
		if yoksa[2] then
			local nesne = getirAsilAdaGore(yoksa[2], self._yil, self._tip)
			return mw.title.new("Kategori:"..self:getirKategoriAdi()).exists and self or nesne
		else
			return "yok"
		end
	else
		return nil
	end
end


function Kategori:getirOncesiSonrasi()
	local function oncelikSapta(ad)
		local n = getirAsilAdaGore(ad, self._yil, self._tip)
		return n:getirOncesiSonrasi() or n
	end
	
	if self._rawData.oncesi or self._rawData.sonrasi or self._rawData.arasi then
		local arasi = self._rawData.arasi
		local oncesi = self._rawData.oncesi
		local sonrasi = self._rawData.sonrasi
		
		local araYil1 = arasi and siralamaSapta(arasi[1][1], self._tip) or nil
		local araYil2 = arasi and siralamaSapta(arasi[1][2], self._tip) or nil
		local onceYil = oncesi and siralamaSapta(oncesi[1], self._tip) or nil
		local sonraYil = sonrasi and siralamaSapta(sonrasi[1], self._tip) or nil
		local yil = bulvedeg(bulvedeg(self._yil, "'l[ae]r", ""), "MÖ ", "-")
		yil = bulvedeg(yil, ". yüzyıl", "")
		yil = bulvedeg(yil, ". binyıl", "")
		
		if oncesi and not oncesi[2] and tipeGorePar(self._tip, {nil, nil, true, true}) then
			return "yok"
		end
		
		if onceYil and yil and tonumber(yil) < tonumber(onceYil) then
			return oncesi[2] and oncelikSapta(oncesi[2]) or "yok"
		elseif sonraYil and yil and tonumber(yil) > tonumber(sonraYil) then
			return sonrasi[2] and oncelikSapta(sonrasi[2]) or "yok"
		elseif araYil1 and araYil2 and yil and tonumber(yil) >= tonumber(araYil1) and tonumber(yil) <= tonumber(araYil2) then
			return arasi[2] and getirAsilAdaGore(arasi[2], self._yil, self._tip) or "yok"
		elseif self._tip == "göre" then
			return oncesi and not oncesi[2] and "yok" or (sonrasi and not sonrasi[2] and "yok" or nil)
		else
			return nil
		end
	else
		return nil
	end
end


function Kategori:getirUstYil()
	return tipeGorePar(self._tip, {
		onYil(self._yil), yuzYil(self._yil), binYil(self._yil)
	})
end


function Kategori:getirVikiveri()
	return mw.wikibase.getEntity(mw.wikibase.getEntityIdForCurrentPage())
end


function Kategori:sonHarfSil(kademe)
	local shs = self._rawData.sonHarfSil
	local shs2 = self._rawData.sonIkiHarfSil
	local asilAd = self:getirAsilAd(kademe or nil)
	
	if type(shs) == "table" then
		shs = tipeGorePar((kademe and kademe or self._tip), shs)
	end
	
	local _len = string.len(asilAd)
	local son_harf = mw.ustring.sub(asilAd, _len - 1, _len)
	
	if shs == true or shs2 == true then
		if son_harf == "ı" then
			asilAd = mw.ustring.sub(asilAd, 1, -2)
		elseif son_harf == "i" then
			asilAd = mw.ustring.sub(asilAd, 1, -2)
		elseif son_harf == "ri" then
			asilAd = mw.ustring.sub(asilAd, 1, -2)
		elseif son_harf == "rı" then
			asilAd = mw.ustring.sub(asilAd, 1, -3)
		else
			son_harf = mw.ustring.sub(asilAd, _len - 2, _len)
			if son_harf == "i" then
				asilAd = mw.ustring.sub(asilAd, 1, -2)
			else
				son_harf = mw.ustring.sub(asilAd, _len - 3, _len)
				if son_harf == "ı" then
					asilAd = mw.ustring.sub(asilAd, 1, -2)
				else
					asilAd = mw.ustring.sub(asilAd, 1, -1)
				end
			end
		end
	end
	
	return asilAd
end


function Kategori:getirEbeveynler()
	local ebeveynler = {}

	--ebeveynlerin listesi
	islem = self._rawData.ebeveynler or {}
	local tip = self._tip

	--her ebeveynimizi nesneye dönüştürüyoruz
	for _,ebeveyn in ipairs(islem) do
		--normalde ana dizinimiz kategoriler'dir, fakat "göre" tipli kategorilerde
		if ebeveyn == "kategoriler" and tip ~= "göre" then ebeveyn = "" end
		--bu ebeveynlerin birer döneme göre ... kategorisi mevcut değildir
		if ebeveyn == "yıllar" or ebeveyn == "onyıllar" or ebeveyn == "yüzyıllar" or ebeveyn == "binyıllar" then tip = "üst" end
		--eğer kategorinin ebeveynlerinden birisi normal
		--yıl kategorilerinde farklı isme, ama göre kategorilerinde
		--farklı isme sahipse bunu ayırt edelim
		local ebNesne = getirAsilAdaGore(ebeveyn, self._yil, tip)
		if tip == "göre" and ebNesne:donustur() and self:getirAsilAd() ~= ebNesne:donustur() then
			table.insert(ebeveynler, getirAsilAdaGore(ebNesne:donustur(), self._yil, tip))
		end
		--burada da kademezi yıldan değil de daha yukarıdan başlayan kategoriler için
		--"[YIL] kişileri" ve "[ONYIL] kişileri" kategorilerinin oluşmasından kaçınıyoruz
		if ebNesne:kademeYok()
		or (tip == "göre" and ebNesne:donustur() and self:getirAsilAd() ~= ebNesne:donustur()) then else
			if ebNesne:getirOncesiSonrasi() then
				if type(ebNesne:getirOncesiSonrasi()) == "string" and
					ebNesne:getirOncesiSonrasi() == "yok" then else
					table.insert(ebeveynler, ebNesne:getirOncesiSonrasi())
				end
			elseif ebNesne:getirYoksa() then
				if type(ebNesne:getirYoksa()) == "string" and
					ebNesne:getirYoksa() == "yok" then else
					table.insert(ebeveynler, ebNesne:getirYoksa())
				end
			else
				table.insert(ebeveynler, ebNesne)
			end
		end
	end
	
	--[[
		ebeveynleri çağırırken, her birini yeni bir kategori nesnesi olarak çağıracağız,
		fakat, normal ebeveyn nesnelerinin dışında her bir kategorinin kendisine ait
		bir üst kategorisi vardır; mesela 2010'da eserler'in üst kategorisi: 2010'larda eserler
		onun da bir üstü 21. yüzyılda eserler; bu üst kategorilerin var olup olmadığını
		kontrol etmek gerekiyor
	--]]
	if self:getirUstTip() then
		table.insert(ebeveynler, getirAsilAdaGore(self:getirAsilAd(), self:getirUstYil(), self:getirUstTip()))
	end

	--[[
		işte burası eğer ebeveynlerde bir "göre" kategorisi yoksa
		otomatik "Yıla göre .." veya "Yüzyıla göre .." düzeninde
		kategoriler ekleniyor
		
		eğer self:sonHarfSil() fonksiyonunu kullanıyorsa bir nesne,
		bunun "Yıla göre .." kategorisi eklenirken en sondan bir harfi silinir
		sebebi de, mesela "2010 kişileri" kategorisini "Yıla göre kişileri"
		değil de "Yıla göre kişiler" yapmalıyız, bu tarz kategorilerde "sonHarfSil"
		değeri mevcuttur, bu da bu işlemin yapılmasına olanak sağlar
	--]]
	local katAd = self:sonHarfSil()
	if katAd ~= "" and tip ~= "göre" then
		if bul(katAd, "göre") and not self:basta() then
			table.insert(ebeveynler, getirAsilAdaGore(tip.."a ve "..katAd, self._yil, self._tip))
		else
			table.insert(ebeveynler, getirAsilAdaGore(tipHallet(katAd, tip), self._yil, self._tip))
		end
	end
	
	--tüm nesnelerin çıktısı
	return ebeveynler or {}
end


function Kategori:getirBak()
	local bak = self._rawData.bak or {}
	local son = {}
	
	if self._tip == "göre" then
		for _,b in ipairs(bak) do
			local baslik = mw.getContentLanguage():ucfirst(tipHallet(b, self._yil))
			if mw.title.new("Kategori:"..baslik).exists then table.insert(son, baslik) end
		end
	else
		for _,b in ipairs(bak) do
			local baslik = mw.getContentLanguage():ucfirst(getirAsilAdaGore(b, self._yil, self._tip):getirKategoriAdi())
			if mw.title.new("Kategori:"..baslik).exists then table.insert(son, baslik) end
		end
	end
	
	return son
end


function Kategori:getirAciklama()
	if self._rawData.aciklama then
		return mw.getContentLanguage():ucfirst(parametreleriHallet(self._rawData.aciklama, self:getirYil(), self:getirTip(), self._yil))
	elseif bul(mw.title.getCurrentTitle().text, "^MÖ") then
		return "Bu kategori "..mw.title.getCurrentTitle().text.." içindir."
	else
		return "Bu kategori "..mw.getContentLanguage():lcfirst(mw.title.getCurrentTitle().text).." içindir."
	end
end


function Kategori:getirTip()
	return self._tip
end


function Kategori:getirUstTip()
	if self._tip == "yıl" and self._rawData.kademe and self._rawData.kademe > 1 then
		return "onyıl"
	elseif self._tip == "onyıl" and self._rawData.kademe and self._rawData.kademe > 2 then
		return "yüzyıl"
	elseif self._tip == "yüzyıl" and self._rawData.kademe and self._rawData.kademe > 3 then
		return "binyıl"
	end
end


function Kategori:getirVeriModulu()
	return self._modul
end


function Kategori:getirSiraAnahtari()
	local zincir = {}
	local siraAnahtarlari = {}
	
	--buradaki seviyeler tablosu aynı ebeveynlerde olduğu
	--gibi onlarla eşleşecek şekilde çalışıyor
	local anahtarlar = {["yıl"]="YSON", ["onyıl"]="YSONİKİ", ["yüzyıl"]="DORTLU", ["binyıl"]="DORTLU"}
	
	for s,a in ipairs(self._rawData.sira_anahtari or {}) do
		table.insert(zincir, a)
	end
	
	if self:getirUstTip() then
		table.insert(zincir, anahtarlar[self._tip])
	end
	
	for i, ebeveyn in ipairs(self._rawData.ebeveynler or {}) do
		local ebNesne = getirAsilAdaGore(ebeveyn, self._yil, self._tip)
		if ebNesne:kademeYok() then
			table.remove(zincir, i)
		end
		if ebNesne:getirOncesiSonrasi() then
			if type(ebNesne:getirOncesiSonrasi()) == "string" and
				ebNesne:getirOncesiSonrasi() == "yok" then
				table.remove(zincir, i)
			end
		end
		if ebNesne:getirYoksa() then
			if type(ebNesne:getirYoksa()) == "string" and
				ebNesne:getirYoksa() == "yok" then
				table.remove(zincir, i)
			end
		end
	end
	
	table.insert(zincir, "DORTLU")

	for _,anahtar in ipairs(zincir) do
		if anahtar == "YSON" then anahtar = mw.ustring.sub( self._yil, -1 )
		elseif anahtar == "YSON-1" then anahtar = mw.ustring.sub( tostring(tonumber(self._yil)-1), -1 )
		elseif anahtar == "YSONİKİ" then anahtar = mw.ustring.sub( self._yil, -2 )
		elseif anahtar == "YIL" then anahtar = self._yil
		elseif anahtar == "DORTLU" then anahtar = bul(self._yil, "-") and "-"..tostring(9999+tonumber(self._yil))
			or (string.len(self._yil) == 1 and "000"..self._yil
			or (string.len(self._yil) == 2 and "00"..self._yil
			or (string.len(self._yil) == 3 and "0"..self._yil
			or (string.len(self._yil) == 4 and self._yil)))) end
		table.insert(siraAnahtarlari, anahtar)
	end

	return siraAnahtarlari
end


function Kategori:toJSON()
	local ret = {
		ebeveynler = self:getirEbeveynler(),
		aciklama = self:getirAciklama(),
		asilAd = self:getirAsilAd(),
		yil = _yil,
		tip = _tip,
		sira_anahtari = self:getirSiraAnahtari(),
		sonHarfSil = self:sonHarfSil(),
		}
	
	return require("Modül:JSON").toJSON(ret)
end


function Kategori:getRawData()
	return self._rawData
end


Kategori.__index = Kategori


function olusturNesne(asilAd, veri, yil, tip, modul)
	return veri and
		setmetatable({ _rawData = veri, _asilAd = asilAd, _yil = yil, _tip = tip, _modul = modul }
			, Kategori)or nil
end


function tipHallet(ad, tip)
	local donKont = getirAsilAdaGore(ad, nil, tip)
	local goreSon = donKont:goreSon()
	local basta = donKont:basta()
	ad = donKont:donustur() and donKont:donustur() or ad

	tip = bul(ad, "kurulan") and "kurulduğu "..tip
		or (bul(ad, "kurulmuş") and "kurulduğu "..tip)
		or (bul(ad, "feshedil") and "feshedildiği "..tip)
		or (bul(ad, "feshedilmiş") and "feshedildiği "..tip)
		or (bul(ad, "varlığı sona eren") and "feshedildiği "..tip)
		or (bul(ad, "kapa[tn][ıa][ln]") and "feshedildiği "..tip)
		or (bul(ad, "başlayan") and "başladığı "..tip)
		or (bul(ad, "başlatılan") and "başladığı "..tip)
		or (bul(ad, "sona eren") and "sona erdiği "..tip)
		or (bul(ad, "tamamlan") and "tamamlandığı "..tip)
		or (bul(ad, "tanıtıl") and "tanıtıldığı "..tip)
		or (bul(ad, "tanımlan") and "tanımlandığı "..tip)
		or (bul(ad, "verilen") and "verilmeye başlandığı "..tip)
		or (bul(ad, "oluşturulan") and "oluşturulduğu "..tip)
		or (bul(ad, "doğan%s") and "doğduğu "..tip)
		or (bul(ad, "doğumlu%s") and "doğduğu "..tip)
		or (bul(ad, "ölen%s") and "öldüğü "..tip)
		or (bul(ad, "keşfedilen%s") and "keşfedildiği "..tip)
		or (bul(ad, "fırlatılan%s") and "fırlatıldığı "..tip)
		or (bul(ad, "geçen%s") and "geçtiği "..tip)
		or (bul(ad, "yapan%s") and "yaptığı "..tip)
		or (bul(ad, "açılan%s") and "açıldığı "..tip)
		or tip
	
	for _,d in ipairs(degerler) do
		ad = bulvedeg(ad, d.."%s", "")
	end
	
	if goreSon then
		return ad.." "..tip.."l"..(bul(tip, "dönem$") and "e" or "a").."r"
	elseif basta and not bul(ad, "göre") and not donKont:donustur() then
		bas = type(basta) == "table" and tipeGorePar(tip, basta) or basta
		return bas .. " " .. tip
			..(bul(tip, "dönem$") and "e" or "a")
			..(bul(ad, "göre") and " ve " or " göre ") .. bulvedeg(ad, bas, "")
	else
		return tip
			..(bul(tip, "dönem$") and "e" or "a")
			..(bul(ad, "göre") and " ve " or " göre ")
			..ad
	end
end


function getirAsilAdaGore(asilAd, yil, tip)
	local altsayfalar = {
		"veri",
		"veri/kişiler",
		"veri/sanat",
		"veri/bilim",
		"veri/kıtalara göre",
		"veri/şehirlere göre",
		"veri/yapılar",
		"veri/spor",
		"veri/hukuk",
		"veri/oluşumlar",
	}
	
	local verimodulu
	
	for _, altsayfa in ipairs(altsayfalar) do
		verimodulu = "Modül:Kategori/" .. altsayfa
		if require(verimodulu)[asilAd] then
			asilAd = type(require(verimodulu)[asilAd]) == "string" and require(verimodulu)[asilAd] or asilAd
			break
		end
	end
	
	tablo = mw.loadData(verimodulu)
	
	if not tablo[asilAd] then
		tablo = {[asilAd] = {}}
		if asilAd == "" then
			tablo[""] = {
				ebeveynler = {tip.."lar"},
				sira_anahtari = {"DORTLU"},
				kademe = 4,
			}
		end
		if bul(asilAd, "göre") then
			tip = "göre"
			tablo[asilAd] = {
				ebeveynler = {bulvedeg(asilAd, ".*göre%s", "")},
				sira_anahtari = {mw.ustring.char(0x0020)},
			}
		end
		verimodulu = "Modül:Kategori"
	end
	
	return olusturNesne(asilAd, tablo[asilAd], yil, tip, verimodulu)
end

---*---*---*---*---*---*---*---*---*---*---*---*---
-- nesneleri kategori sayfalarında yansıtan
-- fonksiyonlar
---*---*---*---*---*---*---*---*---*---*---*---*---

local function duzenleBag(altKat)
	--her kategoride "veriyi düzenle" bağlantısını eklemeye yarayan fonksiyon
	return "<div class=\"main-box main-box-for-all plainlinks\" style=\"float:right;padding:0\">\n{| class=\"main-table\"\n![" ..
		mw.getCurrentFrame():callParserFunction{name = "fullurl", args = {altKat, action = "edit"}} ..
		" Kategori verisini düzenle]\n|}</div>"
end

function parametreleriHallet(ad, yil, tip, yil2)
	local sonuc = ad
	
	if tip == "göre" then
		yil = tipHallet("", yil2)
	end
	if yil then
		sonuc = bulvedeg(sonuc, "{{{yıl}}}", yil)
		sonuc = bulvedeg(sonuc, "{{{yılda}}}", yilEki(yil))
	end
	
	return sonuc
end

--bu fonksiyon bir kategorinin bulunduğu yıla göre üst kısımda
--bir gezinti çubuğu oluşturur
function gezintiCubugu(kategori)
	--en başta bir tablo oluşturuyoruz, en sonda
	--bu tablonun içine sırayla yüklediğimiz gezinti
	--bağlantılarının çıktısını alacağız
	local tablo = {}
	
	--[[
		bu :getirAsilAd() değeri, bir kategori türünün yıldan
		sonra gelen kısmıdır, yani 2010'de eserler kategorisinde
		bu değer "eserler" dir
	
		burada sayfa son ekini belirliyoruz, yani herhangi bir yıldan
		sonra kategorinin adında gelen kısım, bunu kod satırı azaltmak
		amacıyla burada belirttik
	
		burada kontrol ettiğimiz şey de şu, eğer iki farklı değerimiz
		var ise, yani 2010 yılında doğanlar kategorisinde normalde
		bu değerin "yılında doğanlar" olması gerekir, fakat bunun bir üst
		kategorisi "2010'larda doğanlar" olduğu için burada iki farklı
		değeri birbirinden ayırmamız gerekiyor
	--]]
	local sayfa = kategori:getirAsilAd()
	
	--eğer en baştaki yıl değerine sonradan ihtiyacımız olursa diye,
	--bir sonYil değeri belirtiyoruz, çünkü gezinti çubuğunda sürekli
	--bu değer üzerinde oynama yapacağız
	local yil = kategori:getirYil()

	local function tekrarla(y, tip, sayfa, mo)
		local function mevcutMu(sayfa)
			return mw.title.new('Kategori:' .. sayfa).exists
		end
		--5 tane alt kategori, 5 tane de üst kategoriyi çağırmalıyız
		for i = -5, 5 do
			--burada döngü her seferinde sayıyı bir artırarak
			--bize bir sonraki yıl değerini verecek
			local arYil = tipeGorePar(tip, {
				yilBul(y, i), onYil(y, i..0), yuzYil(y, i, tip), binYil(y, i, tip)
			})
			son = getirAsilAdaGore(sayfa, arYil, tip)
			son = (son:getirOncesiSonrasi() and type(son:getirOncesiSonrasi()) ~= "string")
				and son:getirOncesiSonrasi() or son
			--şimdi sayfaları kontrol edelim
			local cubukAdi = (mo and i ~= 0) and bulvedeg(son:getirCubukAdi(), "MÖ ", "") or son:getirCubukAdi()
			--eğer kategorimiz "2020'de eserler" gibi "de, da" eki
			--içeren bir kategoriyse
			if mevcutMu(son:getirKategoriAdi()) then
				table.insert(tablo, '\n*[[:Kategori:' .. son:getirKategoriAdi() .. "|" .. cubukAdi .. "]]")
			else
				--ya da o yıla dair, mevcut kategori türünde hiçbir sayfa mevcut değilse
				table.insert(tablo, '\n*<span style="color:#888">' .. cubukAdi .. "</span>")
			end
		end
	end
	
	local function ebeveynKontrol(kategori, tablo, tip)
		if kategori:getirUstTip() and kategori:getirUstTip() == tip then
			--eğer bir yıl kategorisinin içerisindeysek ve ebeveyn kategoriler mevcutsa,
			--yani "2020'de eserler" için "2020'lerde eserler" kategorisi mevcutsa
			--bir ebeveyn çubuk tablo başı çağırabiliriz
			table.insert(tablo, '\n|}</div>')
			table.insert(tablo, '\n{| class="toccolours hlist" style="border: none; background: transparent;"'
				.. '\n! style="font-weight:400" |')
		end
	end
	
	--asil gezinti çubuğunun tablo başlangıcı
	table.insert(tablo, '<center><div style="padding-bottom: 10px"><div class=\"main-box\" style=\"display:inline-block;padding:0;margin-bottom:0;\">\n{| class="main-table hlist"'
		.. '\n! style="font-weight:400" |')
	
	--eğer bir yıl kategorisindeysek direk asil gezinti çubuğunda
	--yılları listeleyebiliriz
	if kategori:getirTip() == "yıl" then
		local mo = tonumber(bulvedeg(yil, "[^0-9]", "")) > 5
		if mo and bul(yil, "MÖ ") then
			table.insert(tablo, "\n*<span style='color:#888'>'''MÖ'''</span>")
		end
		tekrarla(yil, "yıl", sayfa, mo)
	end
	
	--ONYIL
	ebeveynKontrol(kategori, tablo, "onyıl")
	--şimdi gelelim on yılları listelemeye
	--eğer bir yıl veya on yıl kategorisindeysek on yılları listeleyebiliriz
	if (kategori:getirUstTip() and kategori:getirUstTip() == "onyıl") or kategori:getirTip() == "onyıl" then
		mo = tonumber(bulvedeg(yil, "[^0-9]", "")) > 50
		if mo and bul(yil, "MÖ ") then
			table.insert(tablo, "\n*<span style='color:#888'>'''MÖ'''</span>")
		end
		tekrarla(yil, "onyıl", sayfa, mo)
	end
	
	--YÜZYIL
	ebeveynKontrol(kategori, tablo, "yüzyıl")
	--şimdi gelelim yüzyılları listelemeye
	--eğer on yıl veya yüzyıl kategorisindeysek yüzyılları listeleyebiliriz
	if (kategori:getirUstTip() and kategori:getirUstTip() == "yüzyıl") or kategori:getirTip() == "yüzyıl" then
		mo = tonumber(bulvedeg(kategori:getirTip() == "yüzyıl" and yil or yuzYil(yil), "[^0-9]", "")) > 5
		if mo and bul(yil, "MÖ ") then
			table.insert(tablo, "\n*<span style='color:#888'>'''MÖ'''</span>")
		end
		tekrarla(kategori:getirTip() == "yüzyıl" and yil or yuzYil(yil), "yüzyıl", sayfa, mo)
	end
	
	--BİNYIL
	ebeveynKontrol(kategori, tablo, "binyıl")
	--şimdi gelelim binyılları listelemeye
	--eğer yüzyıl veya binyıl kategorisindeysek binyılları listeleyebiliriz
	if (kategori:getirUstTip() and kategori:getirUstTip() == "binyıl") or kategori:getirTip() == "binyıl" then
		mo = tonumber(bulvedeg(kategori:getirTip() == "binyıl" and yil or binYil(yil), "[^0-9]", "")) > 5
		if mo and bul(yil, "MÖ ") then
			table.insert(tablo, "\n*<span style='color:#888'>'''MÖ'''</span>")
		end
		tekrarla(kategori:getirTip() == "binyıl" and yil or binYil(yil), "binyıl", sayfa, mo)
	end
	
	--sonunda tüm gezinti çubuklarının kapanışını yapıyoruz
	table.insert(tablo, '\n|}\n</div></center>')
	
	--ve hepsinin çıktısı da burada alınıyor
	return table.concat(tablo)
end

--yıllara ek getirmeye yarayan fonksiyon
--örnek olarak 2010'da veya 2015'te
function yilEki(yil)
	--bu durum ondalık yıllarda kullanılma durumlarında geçerlidir
	--yani 2010'larda, 2080'lerde gibi
	if bul(yil, "l[ea]r$") then
		local harf = mw.ustring.sub(yil, -2, -2)
		return yil .. "d" .. harf
	elseif bul(yil, "yüzyıl$") or bul(yil, "binyıl$") then
		return yil .. "da"
	elseif bul(yil, "%d") then
		--[[buradaki durumlarda bir yıla ek getirmek içindir
		    yani 2009'da veya 2003'te gibi
		    eğer yılın son rakamı "3,4,5" ise ekimizin ilk harfi
		    t olmalı çünkü bu rakamlarda kalın ek kullanıyoruz
		    bunların dışındaki durumlarda ise "d olacak"
		--]]
		local ilkek = bul(yil, "[345]$") and "t" or "d"
		--ve eğer son rakam "0,6,9" ise ekimizin ikinci harfi
		--a olur, kalan durumlarda ise e
		local sonek = bul(yil, "[069]$") and "a" or "e"
		--yukarıdaki durumlar birleştirildiğinde "de, da, te, ta"
		--eklerini elde edip çıkartacağız
		ilkek = (bul(yil, "40$") or bul(yil, "60$") or bul(yil, "70$")) and "t" or ilkek
		sonek = (bul(yil, "00$") or bul(yil, "20$") or bul(yil, "50$") or bul(yil, "70$") or bul(yil, "80$")) and "e" or sonek
		return yil .. "'" .. ilkek .. sonek
	else
		return yil
	end
end

--[[bu fonksiyon kategori adındaki yılı ve kategori tipini
    ayırt edip ayıklamaya yarar
    mesela "2017'de başlayan internet dizileri" kategorisini
    ele alalım bu ad, işleme sokulduğunda çıktıda elimize
    birinci değeri "2017" olan ve ikinci değeri de
    "yılda başlayan internet dizileri" olan bir tablo verir
--]]
function karsilastirYillari(ad)
	--yıl değerini başlatıyoruz
	local yil = ""
	local tip
	
	--bu bir MÖ yıl kategorisi mi?
	if bul(ad, "MÖ%s%d") then
		ad = bulvedeg(ad, "MÖ%s", "")
		mo = true
	end
	
	--kesme işareti bulunan bir sözcüğüz mü var?
	if bul(ad, "%a'[dt][ea]") then
		
	end
	
	--eğer girilen adın en başında bir rakam bulunuyorsa
	--bu demektir ki yılımız kategorinin başında mevcut
	--bu yılı en baştan ayıklayabiliriz
	if mw.ustring.match(ad, "%d+") then
		yil = mw.ustring.match(ad, "%d+")
		ad = bulvedeg(ad, yil, "SAYI")
		--eğer bir yıl saptayabildiysek bunu onaylayalım
		yilVarMi = true
	end
	
	--bir yıl değerimiz varsa
	if yilVarMi then
		--yılda de da eki varsa bunu silmemiz gerek
		--çünkü veri modülünden kategoriyi çağırırken
		--"yılda" ile başlayan değerler ile çağıracağız
		if bul(ad, "SAYI'[dt][ea]ki") then
			ad = bulvedeg(ad, "SAYI'[dt][ea]ki", "")
			tip = "yıl"
		elseif bul(ad, "SAYI'[dt][ea]") then
			ad = bulvedeg(ad, "SAYI'[dt][ea]", "")
			tip = "yıl"
		elseif bul(ad, "SAYI'l[ea]rd[ea]ki") then
			ad = bulvedeg(ad, "SAYI'l[ea]rd[ea]ki", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI'l[ea]rd[ea]") then
			ad = bulvedeg(ad, "SAYI'l[ea]rd[ea]", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI'l[ea]r") then
			ad = bulvedeg(ad, "SAYI'l[ea]r", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI'l[ea]r") then
			ad = bulvedeg(ad, "SAYI'l[ea]r", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI. yüzyıldaki") then
			ad = bulvedeg(ad, "SAYI. yüzyıldaki", "")
			tip = "yüzyıl"
		elseif bul(ad, "SAYI. yüzyılda") then
			ad = bulvedeg(ad, "SAYI. yüzyılda", "")
			tip = "yüzyıl"
		elseif bul(ad, "SAYI. yüzyıl") then
			ad = bulvedeg(ad, "SAYI. yüzyıl", "")
			tip = "yüzyıl"
		elseif bul(ad, "SAYI. binyıldaki") then
			ad = bulvedeg(ad, "SAYI. binyıldaki", "")
			tip = "binyıl"
		elseif bul(ad, "SAYI. binyılda") then
			ad = bulvedeg(ad, "SAYI. binyılda", "")
			tip = "binyıl"
		elseif bul(ad, "SAYI. binyıl") then
			ad = bulvedeg(ad, "SAYI. binyıl", "")
			tip = "binyıl"
		else
			tip = "yıl"
			ad = bulvedeg(ad, "SAYI", "")
		end
		ad = bulvedeg(ad, "%s%s", " ")
		ad = bulvedeg(ad, "^%s", "")
		ad = bulvedeg(ad, "%s$", "")
		--çıktı tablomuzu alalım
		return {(mo and "-" or "") .. yil, ad, tip}
	else
		return {nil, ad}
	end
end

local function siraliSablon(sablon, t, l)
	if l[1] then
		table.insert(t, mw.getCurrentFrame():expandTemplate{
			title = sablon,
			args = {l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]}})
	end
end

local function commons(kat, tablo)
	if kat:getirVikiveri() and kat:getirVikiveri().claims and kat:getirVikiveri().claims["P373"] then
		table.insert(tablo, mw.getCurrentFrame():expandTemplate{
			title = "Commons kategori",
			args = {kat:getirVikiveri():formatPropertyValues("P373").value}})
	end
end

local function styles (CSS_page)
	return mw.getCurrentFrame():extensionTag{
		name = "templatestyles", args = { src = CSS_page }
	}
end

function goster(frame)
	--ilk parametreye girilen değeri veya direk kategori adını işleme alalım
	local ad = frame:getParent().args[1] or mw.title.getCurrentTitle()["text"]

	-- MS için düzeltme
	ad = bulvedeg(ad, "MS ", "")

	--en son çıktı verecek kategoriler tablosu
	local kategoriler = {}
	--en son çıktı verecek görüntülenecek nesneler tablosu
	local goruntuler = {}
	
	--kategori sayfamızda bahsi geçen yıl
	local yil = karsilastirYillari(ad)[1]
	--kategori nesnemizi de çağıralım
	local kategori = getirAsilAdaGore(karsilastirYillari(ad)[2], yil, karsilastirYillari(ad)[3])
	
	table.insert(goruntuler, gezintiCubugu(kategori))
	table.insert(goruntuler, duzenleBag(kategori:getirVeriModulu()))

	--Commons kategorisi
	commons(kategori, goruntuler)
	
	if mw.title.new(ad).exists then
		table.insert(goruntuler, mw.getCurrentFrame():expandTemplate{
			title = "Ana",
			args = {ad}})
	end
	
	siraliSablon("Kategori ayrıca bakınız", goruntuler, kategori:getirBak())
	
	if kategori:getirAciklama() then
		table.insert(goruntuler, kategori:getirAciklama())
	end
	
	son = ""
	--her bir ebeveyn için gerekli kategorileri oluşturmamız gerekiyor
	for sira,ebeveyn in ipairs(kategori:getirEbeveynler()) do
		son = son .. ebeveyn:getirKategoriAdi()
		table.insert(kategoriler, "[[Kategori:" .. ebeveyn:getirKategoriAdi() .. "|" .. kategori:getirSiraAnahtari()[sira] .. "]]")
	end
	
	--kategori boş mu?
	if mw.site.stats.pagesInCategory(mw.title.getCurrentTitle().text, "all") == 0 then
		table.insert(kategoriler, "[[Kategori:Boş kategoriler]]")
	end
	
	return styles("Modül:Kategori/styles.css") .. table.concat(goruntuler) .. table.concat(kategoriler)
end

function gore(frame)
	local args = frame:getParent().args
	
	local kategoriler = {}
	local goruntuler = {}
	
	local yil = args[1]
	local tip = args[2]
	local kategori = getirAsilAdaGore(tip, yil, "göre")
	
	local gore = kategori:gore()
	
	if type(gore) == "table" then
		yukari = gore[2]
		gore = gore[1]
	end
	yukari = yukari or ((gore ~= "üst" and gore ~= "hayır") and gore)

	table.insert(goruntuler, mw.getCurrentFrame():expandTemplate{title = "kapsayıcı kategori", args = {}})
	
	tip = kategori:sonHarfSil() and kategori:sonHarfSil() or tip
	local eski_tip = tip
	for _,d in ipairs(degerler) do
		tip = (yil == "dönem" or gore == "üst") and bulvedeg(tip, "^"..d.."%s", "") or tip
	end
	
	--gezinti çubuğu
	if kategori:kademe() and kategori:kademe() > 1 then
		table.insert(goruntuler, "<center>")
		local donemKat = tipHallet(eski_tip, "dönem")
		if mw.title.new("Kategori:" .. donemKat).exists then
			table.insert(goruntuler, '\n'
				..'[[:Kategori:' .. donemKat
				.. "|"..mw.getContentLanguage():ucfirst(donemKat).."]]</div>")
		elseif yil == "dönem" or gore == "üst" then
			table.insert(goruntuler, '\n'
				..'[[:Kategori:' .. (yukari or tip)
				.. "|"..mw.getContentLanguage():ucfirst(yukari or tip).."]]</div>")
		else
			table.insert(goruntuler, '\n'
				.."'''"
				..mw.getContentLanguage():ucfirst(donemKat).."'''</div>")
		end
		
		table.insert(goruntuler, '<div style="padding-bottom: 10px">'
			..'<div class=\"main-box\" style=\"display:inline-block;padding:0;margin-bottom:0;\">'
			..'\n{| class="main-table hlist"'
			.. '\n|')
		
		for _, kademe in ipairs(kademeler) do
			local kademeAdi = tipHallet(kategori:donustur() and kategori:donustur() or kategori:sonHarfSil(kademe), kademe)
			if mw.title.new("Kategori:" .. kademeAdi).exists then
				table.insert(goruntuler, "\n*[[:Kategori:" .. kademeAdi
					.. "|".. mw.getContentLanguage():ucfirst(tipHallet("", kademe)) .."]]")
			end
		end
		
		table.insert(goruntuler, '\n|}\n</div></div></center>')
	end

	table.insert(goruntuler, duzenleBag(kategori:getirVeriModulu()))
	
	--Commons kategorisi
	commons(kategori, goruntuler)
	
	siraliSablon("Kategori ayrıca bakınız", goruntuler, kategori:getirBak())
	
	if kategori:getirAciklama() then
		table.insert(goruntuler, kategori:getirAciklama())
	end
	
	if yil == "dönem" and gore == "hayır" then
	elseif yil == "dönem" or gore == "üst" then
		table.insert(kategoriler, "[[Kategori:" .. mw.getContentLanguage():ucfirst(yukari or tip) .. "|+]]")
	elseif bul(tip, "^tipe göre") or bul(tip, "^ülkeye göre") then else
		table.insert(kategoriler, "[[Kategori:".. tipHallet(tip, "dönem").. "| ]]")
	end
	
	if kategori:getirEbeveynler() then
		--her bir ebeveyn için gerekli kategorileri oluşturmamız gerekiyor
		for sira,ebeveyn in ipairs(kategori:getirEbeveynler()) do
			table.insert(kategoriler, "[[Kategori:" .. ebeveyn:getirKategoriAdi(kategori:goreTipi()) .. "|"
				.. (mw.site.stats.pagesInCategory(ebeveyn:getirKategoriAdi(kategori:goreTipi()), "subcats") > 200
					and mw.ustring.char(0x0020)
					or ((bul(tip, "^tipe göre") or bul(tip, "^ülkeye göre")) and "+" or kategori:getirSiraAnahtari()[sira]))
				 .. "]]")
		end
	end
	
	return styles("Modül:Kategori/styles.css") .. table.concat(goruntuler) .. table.concat(kategoriler)
end

return {goster = goster, gore = gore, tipHallet = tipHallet, test = test}