#!/usr/bin/python3
#####################################
## This is the Tkinter version
## It is mostly a TMW Vault Wrapper
#####################################
## (C) The Mana World Team, 2021-2024
## Published under the MIT License
## Except cog.png - under GPLv2
#####################################

import requests, json, traceback, subprocess, sys, time, os, uuid, base64
import zipfile, shutil
#import threading #hmac, struct # < - TODO: Necessary for TOTP-remember support
import tkinter as tk
from tkinter.messagebox import showinfo, showerror, askyesno
from functools import partial

OBFS = uuid.getnode() % 256 # Get a number which *usually* doesn't change
OBFS = 185 # <- For debugging (FIXME ^ above didn't held up in practice)
# TODO: Maybe we can do len() for the absolute path to this script
# Then % 256 it so we always have a valid unchanging obfuscation? >_>
print("Obfuscation key = %d" % OBFS) # <- Just to not leave it in plain text

## Internal wrapper for preferences
saveSettings = True; newUser = False
def _savePref():
    global saveSettings, pref
    if not saveSettings:
        return
    dump = json.dumps(pref)
    dump = bytearray(ord(x) ^ int(OBFS) for x in dump)
    dump = base64.b64encode(dump)
    dump = dump.decode('ascii')
    with open("settings.b64", 'w') as raw:
        raw.write(str(dump))
    #print("Preferences updated...")
    return

## Try to load previously saved settings
try:
    with open("settings.b64") as raw:
        pref = base64.b64decode(raw.read())
        ## XXX: use ord() if int(x) fails
        pref = bytearray(int(x) ^ int(OBFS) for x in pref)
        pref = pref.decode('utf8')
        #print(repr(pref))
        pref = json.loads(str(pref))
        print("User settings loaded...")
except:
    print("Failed to load user settings!")
    err = traceback.format_exc().split("\n")[-2]
    print("Error: %s" % err)
    ## Create new dummy prefs so it doesn't crash
    pref = {"user": "",    # <- User Email
            "pass": "",    # <- User Password
            "totp": "",    # <- NYI
            "mana": False, # <- Prefer Mana over ManaVerse
            "plus": False, # <- Prefer ManaPlus over ManaVerse
            "local": True, # <- system-wide vs manaplus/ folder
            "shell": True, # <- output to console
            "discord": None} # <- Whenever to use Discord RPC or not
    ## If it is an error, give an option to not destroy the old settings
    if ("FileNotFoundError" in err):
        _savePref()
        print("New user settings created!")
        newUser = True
    elif (askyesno("Mana Launcher", "Failed to load user settings!\n\nDo you want to create a new one?")):
        _savePref()
        print("New user settings created!")
    else:
        saveSettings = False

## Load the introduction screens if they exist
try:
    from _info import worldGreet
except ImportError:
    worldGreet={}

## Auto-detect if Discord should be used
## Don't crash only if a new FLOSS purist will immediately deleted discordrpc
if pref["discord"] in [True, None]:
    try:
        import discordrpc
    except ImportError:
        if pref["discord"] == None:
            pref["discord"] = False
        else:
            raise

## Value may have changed
if pref["discord"]:
    try:
        _rpc = discordrpc.RPC.set_id(app_id=840427221193195541)
        _rpc.set_activity(
                        state="The Mana World - Minimal",
                        details="Main Menu",
                        large_image="launcher",
                        large_text="Mana Launcher",
                        timestamp=_rpc.timestamp
                        )
    except discordrpc.exceptions.DiscordNotOpened:
        err = traceback.format_exc().split("\n")[-2]
        _rpc = None
        print("Failed to load Discord RPC!\n%s" % err)

## Value may have changed
if not pref["discord"]:
    _rpc = None

## This is how we'll actually update Discord stuff
def RPCUpdate(status, image):
    global _rpc, pref
    if not pref["discord"] or _rpc is None:
        return
    _rpc.set_activity(
                    state="The Mana World - Minimal",
                    details=status,
                    large_image=image,
                    large_text="Mana Launcher",
                    timestamp=_rpc.timestamp
                    )
    return

## Prepare some basic stuff
execute=subprocess.call
serverlist = []
class HoverButton(tk.Button):
    def enter(self, e):
        self["background"] = self["activebackground"]
    def exit(self, e):
        self["background"] = self.defaultBackground

    def __init__(self, **kw):
        tk.Button.__init__(self, **kw)
        self.defaultBackground = self["background"]
        self.bind("<Enter>", self.enter)
        self.bind("<Leave>", self.exit)

## TODO: Get from `sys` args parameters like world auto-selection
## or not using ./manaplus/ as path (but something else) (replace os.getcwd)

#####################################
#VAULT_HOST = "https://localhost:13370"
#SERVERLIST = "http://localhost/launcher"
VAULT_HOST = "https://api.themanaworld.org:13370"
SERVERLIST = "https://updates.tmw2.org/launcher"
# Vault SSL wrapper
vault=requests.Session()
if "localhost" in VAULT_HOST:
    vault.verify=False
#####################################

## Just print stuff to console, bold or not
def stdout(message, bd=False):
    if bd:
        print("\033[1m%s\033[0m" % message)
    else:
        print(message)

## Smart Delay
def sdelay(delta=0.02):
    time.sleep(delta)
    return

## IF Then Else (IFTE)
def ifte(ifs, then, elses):
    if (ifs):
        return then
    else:
        return elses

# Sanitize a command (strip some flow control chars)
# While it covers all control operators and most metacharacters,
# it doesn't covers well the reserved words.
# ...Of course, it relies on this client not being compromised.
def san(cmd):
    return cmd.replace(";", "").replace("|", "").replace(">", "").replace("<", "").replace("&", "").replace("(", "").replace(")", "").replace("\n", "").replace("[[", "").replace("]]", "")

## Returns number of seconds since UNIX EPOCH
def now():
    return int(time.time())

## Update preferences (only after release)
#if not "local" in list(pref.keys()):
#    pref["local"] = True

## Does nothing, validation purposes only
def nullp(arg):
    return

# Search for array[?][key]==search in an array of dicts
# Returns the index, or returns -1
def dl_search_idx(array, key, search):
    try:
        r=next((i for i, item in enumerate(array) if item[key] == search), None)
    except:
        traceback.print_exc()
        r=-1
    return ifte(r is None, -1, r)

## Validates a server entry
def validate_server(srv):
    name="Unknown Server"; ok=False
    try:
        name=srv["Name"]
        #stdout("Validating server \"%s\"..." % name)
        nullp("Host: %s" % srv["Host"])
        nullp("Port: %04d" % srv["Port"])
        nullp("Desc: %s" % srv["Desc"])
        nullp("Link: %s" % srv["Link"])
        nullp("News: %s" % srv["News"])
        nullp("Back: %s" % srv["Back"])
        nullp("UUID: %s" % srv["UUID"])
        nullp("Help: %s" % srv["Help"])
        nullp("Online List: %s" % srv["Online"])
        nullp("Policy: %s" % srv["Policy"])
        if not "Type" in srv.keys():
            srv["Type"]="evol2"
        stdout("Server \"%s\" loaded." % name)
        ok=True
    except:
        traceback.print_exc()
        stdout("Validation for server \"%s\" FAILED!" % name)

    return ok

## Update server list
def update_serverlist(hosti):
    global serverlist, host
    try:
        r=requests.get("%s/server_list.json" % hosti, timeout=10.0)
        if (r.status_code != 200):
            raise AssertionError("Mirror %s seems to be down!\nReturned error %03d\n" % (hosti.replace("https://", "").replace("http://", ""), r.status_code))

        j=json.loads(r.text)

        ## If we reached here, then everything is likely fine
        ## We can now build the persistent data
        print("Fetching server list and assets... %d servers" % len(j))
        for server in j:
            if (validate_server(server)):
                serverlist.append(server)

        ## If we were truly successful, save this host as our mirror
        host = hosti
        return True
    except:
        traceback.print_exc()
        return False

## Updates your soul data
def update_soul():
    global vaultId, vaultToken, mySoul
    ## Fetch soul data
    ## TODO: Doing this here is too inefficient!!
    auth = {"vaultId": vaultId,
            "token": vaultToken}

    r=vault.post(VAULT_HOST+"/souldata", json=auth, timeout=15.0)
    if r.status_code != 200:
        raise Exception("Request error: %d" % r.status_code)
    dat=r.json()
    mySoul["level"]=dat["soulv"]
    mySoul["exp"]=dat["soulx"]
    mySoul["next"]=dat["varlv"]
    mySoul["up"]=dat["lvlup"]
    mySoul["home"]=dat["homew"]
    for s in serverlist:
        if mySoul["home"] == s["UUID"]:
            mySoul["home"] = s["Name"]
            break
    if mySoul["home"] == "VAULT":
        mySoul["home"]="Not Set"
    return

## Show a game info
def info_game(idx):
    showinfo(title=serverlist[idx]["Name"],
             message=serverlist[idx]["Desc"])
    return

## Launch a specific world with its appropriate client
def launch_game(idx):
    PWD=""
    ## Get credentials
    auth = {"vaultId": vaultId,
            "token": vaultToken,
            "world": serverlist[idx]["UUID"]}

    try:
        r=vault.post(VAULT_HOST+"/world_pass", json=auth, timeout=15.0)
        ## We got the access credentials
        if r.status_code == 200:
            auth2=r.json()
            PWD=" -U %s -P %s" % (auth2["user"], auth2["pass"])
        ## We were refused by Vault
        elif r.status_code == 403:
            stdout("Warning: Connection was refused (Vault logout?)")
            return -1
        ## We are rate-limited, try again
        elif r.status_code == 429:
            stdout("Rate limited!")
            return -1
        ## Internal error, maybe?
        else:
            stdout("Get World Auth - Returned error code %d" % r.status_code)
            return -1
    except:
        traceback.print_exc()
        return -1

    ## First login special greeting
    ## This is full of hacks, though
    if auth2["new"]:
        return (idx, PWD)
    return do_real_launch(idx, PWD)

def do_real_launch(idx, PWD):
    global pref
    ## Get/Set basic data
    HOST=serverlist[idx]["Host"]
    PORT=serverlist[idx]["Port"]
    CMD=""
    OPT=""

    ## Using system-wide versus local path
    if pref["local"]:
        CMD=os.getcwd()+"/manaplus/"
        CMD=CMD.replace(" ", "\\ ")
        CWD=CMD[:-1]

    ## Handle server type and client (WIP)
    if not sys.platform.startswith('win'):
        if pref["plus"]:
            CMD+="manaplus"
        elif pref["mana"] and "tmwa" in serverlist[idx]["Type"]:
            CMD+="mana"
        else:
            CMD+="ManaVerse"
        if pref["local"]:
            CMD+=".AppImage"
    else:
        ## Mana and M+ are not available on Windows yet (TODO)
        if pref["local"]:
            CMD+="Mana/manaplus.exe" # FIXME untested
        else:
            CMD+="manaplus.exe"      # FIXME untested

    ## Build the server options
    OPT="-s %s -y %s -p %s -S" % (HOST, serverlist[idx]["Type"], PORT)
    ## Mana "fix"
    if pref["mana"]:
        OPT=OPT[:-2]
    print("%s %s" % (CMD, OPT))

    ## Local or System-Wide Config folders
    if pref["local"]:
        if not sys.platform.startswith('win'):
            OPT+=" -C %s/Config -L %s/Local" % (CWD, CWD)
        else:
            OPT+=" -C %s\\Config -L %s\\Local" % (CWD.replace('/','\\'), CWD.replace('/','\\'))
        ## Mana "fix" (TODO Untested / also, Config may fail)
        if pref["mana"]:
            OPT=OPT.replace(" -L ", " --localdata-dir ")

    ## Update Discord if relevant
    RPCUpdate(serverlist[idx]["Name"], serverlist[idx]["Back"])

    ## Execute the app
    ## TODO: Threading?
    if pref["shell"]:
        app=execute(san("%s %s%s" % (CMD, OPT, PWD)), shell=True) # nosec
    else:
        app=execute(san("%s %s%s" % (CMD, OPT, PWD)), shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) # nosec

    return app

## Lame hack
def greetHack(idx, PWD):
    launch_game_master(idx, PWD)
    world_select()
    return

## Run a game from world selection screen, and handles MLP
def launch_game_master(idx, PWD=None):
    if PWD is None:
        app=launch_game(idx)
    else:
        app=do_real_launch(idx, PWD)
    if type(app) != int:
        try:
            # worldGreet dl_
            greeting=worldGreet[serverlist[idx]["UUID"]]
            greeter(greeting, _dest=partial(greetHack, app[0], app[1]))
            return
        except:
            app=do_real_launch(idx, PWD)

    while app == 7:
        stdout("[CLIENT] Mirror Lake triggered.")
        ## Set credentials
        auth = {"vaultId": vaultId,
                "token": vaultToken}
        r=vault.post(VAULT_HOST+"/getlake", json=auth, timeout=15.0)
        if r.status_code == 200:
            goto=r.json()["world"]
            stdout("MLP Target: %s" % str(goto))
            if goto == "" or goto.lower() == "vault":
                stdout("Mirror Lake False Positive")
                break
            try:
                idx=int(dl_search_idx(serverlist, "UUID", goto))
                app=launch_game(idx)
            except:
                traceback.print_exc()
                break
    return

## Only meaningful on Linux
os.environ["APPIMAGELAUNCHER_DISABLE"]="1"

#################################################################################
## Construct session data
update_serverlist(SERVERLIST)
vaultId = -1
mySoul={}
saveMail = None
savePass = None

#################################################################################
###### Some generic text speed
def greeter(text, _dest=None):
    global canva, serverlist
    canva.destroy()
    canva = tk.Canvas(root, width=400, height=600, bg="#0c3251")
    canva.pack()
    label1 = tk.Label(root, text=text, anchor="s", wraplength=350, justify="center", bg="#0c3251", fg="#fff")
    label1.config(font=('helvetica', 12))
    canva.create_window(200, 300, window=label1)
    button = HoverButton(text="Continue...", command=_dest, width=40, bg="#cc6600", fg="#fff", activebackground="#ee9933")
    canva.create_window(200, 575, window=button)
    return

#################################################################################
## Settings screen
## It likely calls world_select() on return so only accessible from there
## Settings Screen should allow for world linking/unlinking
## Settings Screen should allow to modify anything in prefs[]
prefNotLocal=None; prefDiscord=None; prefMana=None; prefPlus=None; prefLogs=None
def settings():
    global canva, serverlist
    global prefNotLocal, prefDiscord, prefMana, prefPlus, prefLogs
    canva.destroy()
    canva = tk.Canvas(root, width=400, height=600, bg="#0c3251")
    canva.pack()
    label1 = tk.Label(root, text='Settings', bg="#0c3251", fg="#fff")
    label1.config(font=('helvetica', 14))
    canva.create_window(200, 30, window=label1)

    ## Prepare the fake prefs
    prefNotLocal = tk.BooleanVar()
    prefNotLocal.set(pref["local"] != True)
    prefDiscord = tk.BooleanVar()
    prefDiscord.set(pref["discord"] == True)
    prefMana = tk.BooleanVar()
    prefMana.set(pref["mana"] == True)
    prefPlus = tk.BooleanVar()
    prefPlus.set(pref["plus"] == True)
    prefLogs = tk.BooleanVar()
    prefLogs.set(pref["shell"] == True)


    c1 = tk.Checkbutton(root, text="Use system-wide client", variable=prefNotLocal, bg="#0c3251", fg="#f70")
    canva.create_window(200, 60, window=c1)
    c2 = tk.Checkbutton(root, text="Use Discord integration", variable=prefDiscord, bg="#0c3251", fg="#f70")
    canva.create_window(200, 80, window=c2)
    ## Less important/system specific options (TODO)
    if not sys.platform.startswith('win'):
        c3 = tk.Checkbutton(root, text="Use original Mana client", variable=prefMana, bg="#0c3251", fg="#f70")
        canva.create_window(200, 110, window=c3)
        #TODO: Download link broken
        #c4 = tk.Checkbutton(root, text="Use ManaPlus client", variable=prefPlus, bg="#0c3251", fg="#f70")
        #canva.create_window(200, 135, window=c4)
        c5 = tk.Checkbutton(root, text="Verbose logging", variable=prefLogs, bg="#0c3251", fg="#f70")
        canva.create_window(200, 160, window=c5)
    # "Download/Update GPL clients" button
    button = HoverButton(text="Download GPL clients", command=_downloadClient, bg="#cc6600", fg="#fff", activebackground="#ee9933", font="helvetica 12", height=-10)
    canva.create_window(200, 200, window=button)

    ## Set or display your homeworld, but doesn't explain it
    if mySoul["home"] in ["Not Set", "VAULT"]:
        label2 = tk.Label(root, text='Home World:', bg="#0c3251", fg="#fff")
        label2.config(font=('helvetica', 12))
        canva.create_window(50, 250, window=label2)
        _home = tk.StringVar()
        _home.set("-- Set a new home --")
        lista = []
        for s in serverlist:
            if "crossroad" in s["Name"].lower():
                continue
            lista.append(s["Name"])
        drop = tk.OptionMenu(canva, _home, *lista)
        drop.config(bg="#cc6600", fg="#fff") # 0c3251
        drop["menu"].config(bg="#cc6600", fg="#fff") # 0c3251
        canva.create_window(220, 250, window=drop)
        hosav = HoverButton(text="→", command=partial(_setHome, _home), bg="#cc6600", fg="#fff", activebackground="#ee9933")
        canva.create_window(375, 250, window=hosav)
    else:
        label2 = tk.Label(root, text='Home World: %s' % mySoul["home"], bg="#0c3251", fg="#fff")
        label2.config(font=('helvetica', 12))
        canva.create_window(200, 250, window=label2)

    # TODO: Account Linking and Unlinking
    # For that, use a dropdown menu (select world), login, password, ...
    # Then a button "LINK" and "UNLINK". Encapsulate the form in a box
    # TODO Then we can put some permanent multi-world bosses on CR? (Giving EXP)

    ## Save all your settings and return to World Selection screen
    button = HoverButton(text="Save Settings", command=_settingSave, width=40, bg="#cc6600", fg="#fff", activebackground="#ee9933")
    canva.create_window(200, 575, window=button)

def _settingSave():
    pref["local"]   = not prefNotLocal.get()
    pref["discord"] = prefDiscord.get()
    pref["shell"]   = prefLogs.get()
    pref["mana"]    = prefMana.get()
    pref["plus"]    = prefPlus.get()
    _savePref()
    update_soul() # <- Update soul data before canvas is destroyed
    world_select()
    return

## Change your homeworld
def _setHome(_home):
    global serverlist, vault, vaultId, vaultToken, mySoul
    world=None
    for _world in serverlist:
        if _world["Name"] == _home.get():
            world=_world["UUID"]
            break
    if world is not None:
        if askyesno("Mana Launcher", "ARE YOU SURE you want to set your home world?\n\nThis action cannot be undone!\n\nSelected: %s" % _home.get()):
            vault.post(VAULT_HOST+"/sethome", json={"vaultId": vaultId, "token": vaultToken, "home": world}, timeout=15.0)
            #update_soul() # <- Update soul data again (FIXME error 429)
            mySoul["home"] = str(_home.get()) # <- Fake hack
    else:
        print("Error, %s has no UUID, cannot be set as homeworld." % _home.get())
    return

def _downloadClient():
    ## TODO: Show progress bars
    if askyesno("Mana Launcher", "Do you want to download or update the game clients?\n\nThey are licensed under GPLv2 or later. Up to 150 MB of disk space will be required."):
        ## Manaverse for Linux
        if not sys.platform.startswith('win'):
            with open("manaplus/ManaVerse.AppImage", 'wb') as f:
                f.write(requests.get("https://updates.tmw2.org/mana/linux/ManaPlus-x86_64.AppImage", allow_redirects=True).content)
            execute("chmod +x \"%s\"" % "manaplus/ManaVerse.AppImage", shell=True)
        ## Manaverse for Windows
        else:
            with open("manaplus/manaverse.zip", 'wb') as f:
                f.write(requests.get("https://updates.tmw2.org/mana/windows/manaverse.zip", allow_redirects=True).content)
            try:
                shutil.rmtree("manaplus/Mana")
            except:
                pass
            with zipfile.ZipFile("manaplus/manaverse.zip", 'r') as zip_ref:
                zip_ref.extractall("manaplus/")
            os.remove("manaplus/manaverse.zip")
        ## Mana for Linux
        if not sys.platform.startswith('win') and pref["mana"]:
            with open("manaplus/Mana.AppImage", 'wb') as f:
                f.write(requests.get("https://updates.tmw2.org/mana/linux/Mana-x86_64.AppImage", allow_redirects=True).content)
            execute("chmod +x \"%s\"" % "manaplus/Mana.AppImage", shell=True)
    return

#################################################################################
###### World Selection Screen
def world_select():
    global canva, serverlist, mySoul
    canva.destroy()
    canva = tk.Canvas(root, width=400, height=600, bg="#0c3251")
    canva.pack()
    label1 = tk.Label(root, text='World Selection', bg="#0c3251", fg="#fff")
    label1.config(font=('helvetica', 14))
    canva.create_window(200, 30, window=label1)

    ## Not really necessary? Or just TODO?
    ## Without these, max is 10 worlds
    #scrollbar = tk.Scrollbar(canva, orient=tk.VERTICAL)
    #canva.create_window(400, 20, window=scrollbar)

    ## Create a list of all worlds
    ypos = 60
    for w in serverlist:
        ## TODO: Do not block main thread, launch this in a threading?
        ## TODO: Image button if an icon can be found
        button = HoverButton(text=w["Name"], command=partial(launch_game_master, serverlist.index(w)), width=40, anchor="w", bg="#cc6600", fg="#fff", activebackground="#ee9933")
        canva.create_window(200, ypos, window=button)
        ## TODO FIXME: World Info Button
        button = HoverButton(text="?", command=partial(info_game, serverlist.index(w)), bg="#cc6600", fg="#fff", activebackground="#ee9933")
        canva.create_window(370, ypos, window=button)
        ypos += 40

    ## TODO: Footnote: Settings button
    labf = "Lv %d, %d/%d EXP" % (mySoul["level"], mySoul["exp"], mySoul["next"])
    labelf = tk.Label(root, text=labf, bg="#0c3251", fg="#fff")
    labelf.config(font=('helvetica', 13))
    canva.create_window(200, 550, window=labelf)
    labelf = tk.Label(root, text="Home: %s" % mySoul["home"], bg="#0c3251", fg="#fff")
    labelf.config(font=('helvetica', 13))
    canva.create_window(200, 570, window=labelf)

    ## Settings button
    #setbutton = HoverButton(text="Prefs", command=settings, bg="#cc6600", fg="#fff", activebackground="#ee9933", image=_cog_png)
    setbutton = tk.Button(text="Prefs", command=settings, bg="#cc6600", activebackground="#ee9933", image=_cog_png)
    canva.create_window(30, 550, window=setbutton)
    return

#################################################################################
## Login function
def login():
    global canva, vaultId, vaultToken, saveMail, savePass, newUser
    email = entry1.get()
    passw = entry2.get()
    totps = entry3.get()

    ## Save email or delete saved copy
    if saveMail.get():
        pref["user"] = email
    else:
        pref["user"] = ""

    ## Save password or delete saved copy
    if savePass.get():
        pref["pass"] = passw
    else:
        pref["pass"] = ""

    ## Prepare the packet for Vault
    data = {"mail": email,
              "pass": passw,
              "totp": totps[:6]
             }
    try:
        r = vault.post(VAULT_HOST+"/user_auth", json=data)

        if (r.status_code != 200):
            add=""
            if r.status_code == 400:
                add="\nBad request.\n"
            elif r.status_code == 401:
                add="\nIncorrect username/password.\n"
            elif r.status_code == 429:
                add="\nYou are being rate-limited.\n"
            showerror(title="Mana Launcher", message="Vault returned error %d\n%s\nPlease try again later." % (r.status_code, add))
            exit(1)
    except SystemExit:
            exit(1)
    except:
        err = traceback.format_exc().split("\n")[-2]
        print("Error: %s" % err)
        showerror(title="Mana Launcher", message="Python error\n\nPlease try again later.")
        exit(1)

    auth2 = r.json()
    vaultId = auth2["vaultId"]
    vaultToken = auth2["token"]

    ## Only save settings if connection worked
    _savePref()

    ## Change the display
    print("Connected to vault! vaultId = %d" % vaultId)
    update_soul() # <- Update soul data before canvas is destroyed
    ## Do not jump to world selection if it is a new account - show the app intro
    if newUser:
        greeting="""
Welcome to the Mana Launcher\n
\n
With your soul shattered in pieces, you drift along the void.\n
Faint memories of a figure clad in black emerge, what could they be?\n
\n
You might not remember much... But your willpower is not gone.\n
"This is not the end". And with it, the determination to continue and see through the end.\n
\n
Which world will you visit first? For once you finish all of the worlds, your true power shall return to you...
        """
        greeter(greeting, _dest=world_select)
    else:
        world_select()
    return

#################################################################################
## Build Tkinter interface
root=tk.Tk()
root.title("Mana Launcher (tk)")
canva = tk.Canvas(root, width=400, height=600, bg="#0c3251")
canva.pack()

## Default variables
saveMail = tk.BooleanVar()
saveMail.set(pref["user"] != "")
savePass = tk.BooleanVar()
savePass.set(pref["pass"] != "")
_cog_png = tk.PhotoImage(file = "cog.png")

## Email
label1 = tk.Label(root, text='Email:', bg="#0c3251", fg="#fff")
label1.config(font=('helvetica', 14))
canva.create_window(180, 40, window=label1)
entry1 = tk.Entry(root)
entry1.insert(0, pref["user"])
canva.create_window(180, 80, window=entry1)
c1 = tk.Checkbutton(root, text="Remember", variable=saveMail, bg="#0c3251", fg="#f70")
canva.create_window(320, 80, window=c1)


label2 = tk.Label(root, text='Password:', bg="#0c3251", fg="#fff")
label2.config(font=('helvetica', 14))
canva.create_window(180, 120, window=label2)
entry2 = tk.Entry(root, show="*")
entry2.insert(0, pref["pass"])
canva.create_window(180, 160, window=entry2)
c1 = tk.Checkbutton(root, text="Remember", variable=savePass, bg="#0c3251", fg="#f70")
canva.create_window(320, 160, window=c1)


label3 = tk.Label(root, text='TOTP*:', bg="#0c3251", fg="#fff")
label3.config(font=('helvetica', 14))
canva.create_window(180, 210, window=label3)
entry3 = tk.Entry(root)
#entry3.insert(0, pref["totp"])
canva.create_window(180, 240, window=entry3)

## Explanation for noobs
label4 = tk.Label(root, text="* If you don't know what \"TOTP\" is, leave the field blank.", bg="#0c3251", fg="#ffc", anchor="w", wraplength=350, justify="left")
label4.config(font=('helvetica', 10))
canva.create_window(200, 280, window=label4)


button1 = HoverButton(text='Login', command=login, bg="#cc6600", fg="#fff", activebackground="#ee9933")
canva.create_window(200, 320, window=button1)
root.mainloop()

# Check if you were logged in
if vaultId < 1:
    exit(1)

print("Thanks for playing!")
## TODO: Also, we want {b}bold{/b} support >.< https://itecnote.com/tecnote/tkinter-python-tkinter-single-label-with-bold-and-normal-text/