"""

Van een getal in cijfers "98" een getal in letters maken "achtennegentig"
De eenheden en tientallen zijn de basisblokken van getallen maken:
achtennegentig is bijvoorbeeeld "acht" (+ "en") + "negentig"
verder is dit de derde versie die ik inlever,
omdat een groot deel van de basisstructuur veranderd moest worden
vanwege het "eenmiljoen" probleem.
"""
gebruiker_getal = int(input("Welk getal wilt u uitgeschreven hebben? "))

# De extra leeggelaten vakjes zijn straks handig bij het rekenen

eenheden = ["", "een", "twee", "drie", "vier", "vijf", "zes", "zeven", "acht",
"negen"]
tientallen = ["", "tien", "twintig", "dertig", "veertig", "vijftig", "zestig",
"zeventig", "tachtig", "negentig"]

# De speciale getallen zijn geen hele eenheden of tientallen, maar zijn

onregelmatig. De reden dat ze losstaan van de eenheden is voor extra bug-veiligheid
in de code als we gaan printen.
speciaal = {
0: "nul",
11: "elf",
12: "twaalf",
13: "dertien",
14: "veertien",
15: "vijftien",
16: "zestien",
17: "zeventien",
18: "achttien",
19: "negentien",
}

# Deze deel_omzetten is handig voor een paar dingen:

# 1. Alle getallen onder de 1000 worden erin verwerkt
# 2. Ook de grotere getallen, dus in de miljoenen of hoger, zijn in het Nederlands
opgebroken in stukjes van duizend met een schaalwoord eraan geplakt. Dit betekent
dat je kan loopen en zo heel veel schalen kan bereiken
def deel_omzetten(getal):
# De speciale getallen zijn het makkelijkst snel weg te werken
if getal in speciaal:
return speciaal[getal] # De index zoekt hier naar de betekenis in de dict.

# Dan volgt alles onder de 10

elif getal < 10:
return eenheden[getal] # De index is hier de plaats in de lijst, die ook
meteen het getal is :)

# Dan alles onder de honderd

elif getal < 100:

# We splitten hier met twee handige functies het getal uiteen in tientallen
en eenheden
tiental = getal // 10 # De // is hier delen en de rest negeren, zodat 98 //
10 = 9.8 = 9, wat het tiental is
eenheid = getal % 10 # De % is hier delen en alleen de rest houden, zodat
98 % 10 = 9 rest 8 = 8, wat de eenheid is

# De reden dat we apart checken voor een heel tiental is omdat anders
"endertig" zou worden geprint ipv "dertig"
 if eenheid == 0:
return tientallen[tiental]

# Deze check is voor de klinkerbotsing die zich bij twee- en drie- voordoet
elif eenheid == 2 or eenheid == 3:
return eenheden[eenheid] + "ën" + tientallen[tiental]
# Als laatste het "normale" geval
else:
return eenheden[eenheid] + "en" + tientallen[tiental]
# En hier, alles van 101-1000
elif getal < 1000:
honderdtal = getal // 100 # Zelfde functie als net
rest = getal % 100 # De rest gebruiken we zo nog een keer

# Heel simpel checken of het een rond honderdtal is, en honderdtal

genereren ipv in een lijst opslaan
if rest == 0:
# Zie hier de speciale check om "eenhonderd" te voorkomen
if honderdtal == 1:
return "honderd"
else:
return eenheden[honderdtal] + "honderd"
else:
# Hier dezelfde belangrijke check
if honderdtal == 1:
return "honderd" + deel_omzetten(rest)
else:
return eenheden[honderdtal] + "honderd" + deel_omzetten(rest)
# Daar zetten we het honderdtal neer met de rest nog een keer door
de hele code heengehaald erachteraan

# Dit is één van de belangrijkste functies uit de hele code, namelijk dingen als
"eenduizend", "eenmiljoen" etc. verbeteren.
# De gegeven argumenten zijn de woorden die later gegenereerd worden, en het
schaalwoord wat we erachter aan moeten plakken.
def vervang_een(woorden, schaalwoord):
# Deze check zorgt ervoor dat ipv woorden + schaalwoord = "eenduizend",
schaalwoord = "duizend" is. Dit is heel belangrijk en vooral heel irritant.
if woorden == "een":
return schaalwoord
else:
return woorden + schaalwoorden[schaal]

# HIER BEGINT HET UITVOERENDE STUK CODE

# Dit dealt meteen, zonder over schalen na te denken, met alles tot de 1000
if gebruiker_getal < 1000:
print(deel_omzetten(gebruiker_getal))

# Als het getal boven de 1000 is, is er een schaal nodig.

else:
schaalwoorden = ["", "duizend", "miljoen", "miljard", "biljoen", "biljard",
"triljoen", "triljard", "quadriljoen", "quadriljard", "quintiljoen", "quintiljard",
"sextiljoen", "sextiljard", "septiljoen", "septiljard", "octiljoen", "octiljard"] #
Deze kan in theorie doorgaan tot de quinquadragintriljarden en verder, maar we
houden het maar bij een nietige 10^51.
# De schaal en het resultaat, waar alles in wordt gezet
schaal = 0
 resultaat = ""
# Deze while-loop blijft doorgaan tot de laatste schaal
while gebruiker_getal > 0:
# Het huidige deel begint
deel = gebruiker_getal % 1000
# Als het deel nul is, kunnen we het overslaan
if deel != 0:
woorden = deel_omzetten(deel)
resultaat = vervang_een(woorden, schaalwoorden[schaal]) + resultaat
# Het nieuwe resultaat = het nieuwe deel + de schaal + wat al erin
stond, zodat we voorin het nieuwe schrijven
# Naar de volgende stap, schaal eentje groter
schaal += 1
# Het getal wordt gedeeld door 1000, zodat het deel berekenen makkelijker
wordt. De schaal blijft omhoog tikken, terwijl het getal kleiner wordt. Dit is
licht verwarrend, maar ja dat is alles in het leven.
gebruiker_getal //= 1000

print(resultaat)