local p = {}
local kanatrasforma = require("Modulo:ja") --questa funzione locale richiama il Modulo:Ja (importato da en.wikt) e viene utilizzata per trasformare i katakana nei corrispondenti hiragana (per ordinare le categorie alfabeticamente per hiragana)
function p.parolagiappo(frame)

-- variabili richiamate nel template
	tipo = frame.args["tipo"]
	hiragana = frame.args["hiragana"] or ""
	katakana = frame.args["katakana"] or ""
	kana = frame.args["kana"] or ""
	romaji = frame.args["romaji"] or ""
	coniugazione = frame.args["coniugazione"] or ""
	declinazione = frame.args["declinazione"] or ""
	k = frame.args["k"] or ""
	s = frame.args["s"] or ""
	catsort = frame.args["catsort"] or ""

-- variabili interne al modulo
	sorthiragana = ""
	categoria = ""
	hiraganadesc = ""
	katakanadesc = ""
	kanadesc = ""
	romajidesc = ""
	conjlink = ""
	conjdesc = ""
	declink = ""
	decdesc = ""
	kyujitai = ""
	shinjitai = ""
	categoria_composti = ""
	kanji = ""
	kanji1 = ""; kanji2 = ""; kanji3 = ""; kanji4 = ""; kanji5 = ""; kanji6 = ""; kanji7 = ""; kanji8 = ""; kanji9 = ""; kanji10 = ""
	
--stringhe "hiraganadesc", "katakanadesc" e "kanadesc", traducono i parametri "hiragana", katakana" e "kana" passato dal template per generare la corrispondente descrizione
	if hiragana > "0" then --se il parametro "hiragana" è definito...
		hiraganadesc = "''hiragana'' ".. p.wiki(hiragana).. ", " --hiraganadesc restituisce la trascrizione in hiragana, passata dal template
	else --se il parametro "hiragana" non è definito...
		hiraganadesc = "" --hiraganadesc si annulla
	end
	if katakana > "0" then --se il parametro "katakana" è definito...
		katakanadesc = "''katakana'' ".. p.wiki(katakana).. ", " --katakanadesc restituisce la trascrizione in katakana, passata dal template
	else --se il parametro "katakana" non è definito...
		katakanadesc = "" --katakanadesc si annulla
	end
	if kana > "0" then --se il parametro "kana" è definito...
		kanadesc = "''kana'' ".. p.wiki(kana).. ", " --kanadesc restituisce la trascrizione in kana, passata dal template
	else --se il parametro "kana" non è definito...
		kanadesc = "" --kanadesc si annulla
	end
	
--stringa "romajidesc", traduce il parametro "romaji" passato dal template per generare la corrispondente descrizione
	if romaji >"0" then --se il parametro "romaji" è definito...
		if tipo == "Suffissi" then --per suffissi e prefissi, il modulo aggiunge in automatico un trattino al romaji, prima e dopo, altrimenti il template sballa se si mette a mano :/
			romajidesc = "''romaji'' ".. p.wiki("-".. romaji) 
		elseif tipo == "Prefissi" then 
			romajidesc = "''romaji'' ".. p.wiki(romaji.. "-") 
		else --per tutti gli altri tipi grammaticali...
		romajidesc = "''romaji'' ".. p.wiki(romaji) --romajidesc restituisce la trascrizione romaji, passata dal template
		end
	else --se il parametro "romaji" non è definito...
		error(" inserire la trascrizione romaji (Hepburn) della parola, con il parametro |romaji = ") --genera un messaggio di errore, la trascrizione romaji è obbligatoria
	end
	
-- stringa "categoria", traduce il parametro "tipo" del template e crea la relativa categoria, ordinandola per ordine alfabetico dopo il pipe "|" in base alla stringa "sorthiragana", che dipende dai parametri "hiragana", katakana" e "kana" del template 
	if tipo > "0" then
		if catsort > "0" then --se il parametro "catsort" è definito
			sorthiragana =  catsort --sorthiragana è uguale al parametro catsort stesso, per forzare l'ordinamento alfabetico 
		else --se catsort non è definito...
			if hiragana > "0" then --se il parametro "hiragana" è definito...
				sorthiragana = hiragana --sorthiragana è uguale al parametro "hiragana"
			else --se il parametro "hiragana" non è definito...
				if katakana > "0" then --se il parametro "katakana" è definito...
				sorthiragana = kanatrasforma.kata_to_hira(katakana) --sorthiragana è uguale al parametro "katakana", ma TRASFORMATO in hiragana con la funzione locale kanatrasforma
				elseif kana > "0" then --se il parametro "kana" è definito...
				sorthiragana = kanatrasforma.kata_to_hira(kana) --sorthiragana è uguale al parametro "kana", ma TRASFORMATO in hiragana con la funzione locale kanatrasforma
				else --se né hiragana, né katakana e né kana sono definiti, vuol dire che la parola è già in kana nel titolo, quindi...
				sorthiragana = kanatrasforma.kata_to_hira(tostring(mw.title.getCurrentTitle())) --sorthiragana è uguale al titolo della pagina, TRASFORMANDO il tutto in hiragana con la funzione locale kanatrasforma
				end
			end
		end
		categoria = p.cat(tipo.. " in giapponese|".. sorthiragana) --genera la categoria, mettendo dopo il pipe "|" la stringa "sorthiragana" generata sopra
	else --se il parametro "tipo" non è definito...
		error(" specificare il tipo grammaticale della parola (verb, agg, sost etc.) con il parametro |tipo = ") --genera un messaggio di errore, indicare la tipologia grammaticale è obbligatorio
	end

	--stringhe "conjlink" e "conjdesc", traducono il parametro "coniugazione" passato dal template per generare il link alla coniugazione e la descrizione corrispondente
	if tipo == "Verbi" then --se la parola è un verbo, dovrebbe avere una coniugazione
		conjlink = " ([[Appendice:Coniugazioni/Giapponese/Verbi/".. tostring(mw.title.getCurrentTitle()).. "|vai alla coniugazione]]) " --genera il link alla declinazione
		if coniugazione > "0" then --se il parametro "coniugazione" è definito...
			conjdesc = "; ''coniugazione [[".. coniugazione.. "]]''" --genera la descrizione della coniugazione verbale
		else --se il parametro "coniugazione" non è definito...
			error("inserire la desinenza della coniugazione verbale con il parametro |coniugazione =") --genera un messaggio di errore, i verbi dovrebbero aver specificata la desinenza della coniugazione
		end
	else --se la parola non è un verbo, non dovrebbe avere una coniugazione
		conjlink = "" 
		conjdesc = "" --conjlink e conjdesc si annullano
	end
	
--stringhe "declink" e "decdesc", traducono il parametro "declinazione" passato dal template per generare il link alla coniugazione e la descrizione corrispondente
	if tipo == "Aggettivi" then --se la parola è un aggettivo, dovrebbe avere una declinazione
		declink = " ([[Appendice:Coniugazioni/Giapponese/Aggettivi/".. tostring(mw.title.getCurrentTitle()).. "|vai alla coniugazione]]) " --genera il link alla declinazione
		if declinazione > "0" then --se il parametro "declinazione" è definito...
			decdesc = "; ''coniugazione in'' [[-".. declinazione.. "]]" --genera la descrizione della coniugazione aggettivale
		else --se il parametro "declinazione" non è definito...
			error("inserire la desinenza della declinazione aggettivale con il parametro |declinazione =") --genera un messaggio di errore, gli aggettivi dovrebbero aver specificata la desinenza della coniugazione
		end
	else --se la parola non è un aggettivo, non dovrebbe avere una declinazione
		declink = "" 
		decdesc = "" --declink e decdesc si annullano
	end
	
--stringhe kyujitai e shinjitai, traducono i parametri "k" e "s" del template, nel caso di parole con caratteri Kyūjitai 
	if k == "si" then --se il parametro "k" è definito...
		kyujitai = "''Kyūjitai kanji'', " --fornisce la relativa descrizione
		if s > "0" then --se il parametro "s" è definito...
			shinjitai = "''variante Shinjitai'': ".. p.wiki(s).. ", " --fornisce il link alla variante shinjitai
		else --se il parametro s non è definito...
			shinjitai = "" --la stringa shinjitai si annulla
		end
	else --se il parametro "k" non è definito...
		kyujitai = "" --la stringa kyujitai si annulla
	end 

--stringa categoria_composti; se il titolo della pagina contiene dei kanji, genera la categoria "composti di 'x' in giapponese"
	local kanji = mw.ustring.gsub((tostring(mw.title.getCurrentTitle())), '([㐀-䶵一-鿌\239\164\128-\239\171\153𠀀-𯨟])々', '%1%1') --trova i kanji nel titolo della pagina
		kanji = mw.ustring.gsub(kanji, '[^㐀-䶵一-鿌\239\164\128-\239\171\153𠀀-𯨟]',   '') -- rimuove i caratteri hiragana o katakana
	if  kanji > "0"  then --se il titolo contiene dei kanji...
		kanji1 = mw.ustring.sub( kanji, 1, 1 ) or ""; kanji2 = mw.ustring.sub( kanji, 2, 2 ) or ""; kanji3 = mw.ustring.sub( kanji, 3, 3 ) or ""; kanji4 = mw.ustring.sub( kanji, 4, 4 ) or ""; kanji5 = mw.ustring.sub( kanji, 5, 5 ) or ""; kanji6 = mw.ustring.sub( kanji, 6, 6 ) or ""; kanji7 = mw.ustring.sub( kanji, 7, 7 ) or ""; kanji8 = mw.ustring.sub( kanji, 8, 8 ) or ""; kanji9 = mw.ustring.sub( kanji, 9, 9 ) or ""; kanji10 = mw.ustring.sub( kanji, 10, 10 ) or ""; --scompone il titolo nei singoli caratteri che lo compongono (FUNZIONA PER COMPOSTI DI FINO A 10 CARATTERI; se ci dovessero essere parole più lunghe va aggiunto kanji11... etc. proseguendo la numerazione, ma è un'eventualità talmente rara che si fa probabilmente prima a inserire manualmente le categorie mancanti nei lemmi)
			if kanji1 == tostring(mw.title.getCurrentTitle()) then --se la parola è composta da un unico kanji...
				categoria_composti_1 = p.cat("Composti di ".. kanji1.. " in giapponese| ") --genera la categoria lasciando uno spazio vuoto dopo il pipe, più elegante ed evita qualche piccolo inconveniente nel caso di kanji con più letture
				categoria_composti_2 = ""; categoria_composti_3 = ""; categoria_composti_4 = ""; categoria_composti_5 = ""; categoria_composti_6 = ""; categoria_composti_7 = ""; categoria_composti_8 = ""; categoria_composti_9 = ""; categoria_composti_10 = "" --...e le altre si annullano
			else --se la parola è composta da più di un solo kanji, genera le categorie corrispondenti, mettendo l'hiragana dopo il pipe
				if kanji10 > "0" then
					categoria_composti_10 = p.cat("Composti di ".. kanji10.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_10 = ""
				end
				if kanji9 > "0" then
					categoria_composti_9 = p.cat("Composti di ".. kanji9.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_9 = ""
				end
				if kanji8 > "0" then
					categoria_composti_8 = p.cat("Composti di ".. kanji8.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_8 = ""
				end
				if kanji7 > "0" then
					categoria_composti_7 = p.cat("Composti di ".. kanji7.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_7 = ""
				end
				if kanji6 > "0" then
					categoria_composti_6 = p.cat("Composti di ".. kanji6.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_6 = ""
				end
				if kanji5 > "0" then
					categoria_composti_5 = p.cat("Composti di ".. kanji5.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_5 = ""
				end
				if kanji4 > "0" then
					categoria_composti_4 = p.cat("Composti di ".. kanji4.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_4 = ""
				end
				if kanji3 > "0" then
					categoria_composti_3 = p.cat("Composti di ".. kanji3.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_3 = ""
				end
				if kanji2 > "0" then
					categoria_composti_2 = p.cat("Composti di ".. kanji2.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_2 = ""
				end
				if kanji1 > "0" then
					categoria_composti_1 = p.cat("Composti di ".. kanji1.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_1 = ""
				end
			end
			categoria_composti = categoria_composti_1.. categoria_composti_2.. categoria_composti_3.. categoria_composti_4.. categoria_composti_5.. categoria_composti_6.. categoria_composti_7.. categoria_composti_8.. categoria_composti_9.. categoria_composti_10 --genera la categoria per ciascuno dei composti della parola, se presenti, mettendo hiraganasort dopo il pipe
	else --se il titolo non contiene kanji...
		categoria_composti = "" --la categoria si annulla
	end

-- infine, incorpora tutte le stringhe precedentemente definite, generando il testo di output
return
conjlink.. declink.. " (".. kyujitai.. shinjitai.. hiraganadesc.. katakanadesc.. kanadesc.. romajidesc.. conjdesc.. decdesc.. ")".. categoria.. categoria_composti
end

-- questa funzione rende il suo argomento un wikilink
function p.wiki(x)
    return "[[" .. x .."#Giapponese".. "|".. x.. "]]"
end
-- questa funzione crea una categoria a partire dal o dai suoi argomenti
function p.cat(x)
	return "[[Categoria:" .. x .. "]]"
end
return p