import hashengine
import random
import ast
import string
import threading
import mtTkinter as tk
import time
import simpleaudio as sa
import os
import base64

global gamedata
gamedata = {}

class rend:
    def __init__(self, size, cam, container, offset):
        self._size = size
        self._grid = {}
        self._win = container
        self._frame = tk.Frame(container)
        self._cam = cam
        for y in range(size[1]):
            for x in range(size[0]):
                temp = tk.Label(self._frame, text=" ", width=3)
                temp.grid(row=y+offset[1], column=x+offset[0]+1)
                self._win.update()
                self._grid[f"{x}:{y}"] = temp
        self._frame.grid()

    def coltohex(self, target):
        colors = []
        target = [target.r, target.g, target.b]
        for i in target:
            colors.append(("0"*(2-len(hex(i)[2:])))+hex(i)[2:])
        out = ""
        for i in colors:
            out = out + i
        return "#"+out

    def update(self):
        self._win.update()

    def pix(self, x, y, text, bcolor, fcolor):
        if f"{x}:{y}" in self._grid:
            self._grid[f"{x}:{y}"].config(text=text, bg=self.coltohex(bcolor), fg=self.coltohex(fcolor))

class script:
    def __init__(self):
        self.code = ""
    
    def execute(self, API):
        #old code for PCPL code execution, replaced with python code execution
        """
        PCPL.resetvar()
        PCPL.LIS("HASHBASE")
        PCPL.run(self.code)"""
        exec(self.code, API)

def add(objtype):
    obj = getattr(types, objtype)()
    args = {}
    for i in dir(obj):
        if i.startswith("_"): continue
        args[i] = getattr(obj, i)
    temp = {"id": objtype, "args": args, "name": objtype}
    id = ""
    chars = list(string.ascii_letters)
    for i in range(255):
        id = id + random.choice(chars)        
    gamedata[id] = temp
    if objtype in crucial:
        game.addobj(obj)
        gamedata[id]["args"]["ID"] = obj.ID
    return id

def importsound(target):
    oid = add("rawsound")
    gamedata[oid]["name"] = target["name"]
    gamedata[oid]["args"]["sdata"] = base64.b64decode(target["args"]["sdata"])
    gamedata[oid]["args"]["spath"] = target["args"]["spath"]

def importobj(target):
    if target["id"] == "sound" or target["id"] == "rawsound":
        importsound(target)
        return
    oid = add(target["id"])
    id = gamedata[oid]
    id["name"] = target["name"]
    #create arguments
    outargs = {}
    for argname in target["args"]:
        arg = target["args"][argname]
        if isinstance(arg, dict):
            ID = arg.pop("ARGID")
            obj = attypes[ID]()
            for i in arg:
                setattr(obj, i, arg[i])
            arg = obj
        outargs[argname] = arg
    #apply arguments to obj
    if target["id"] in crucial:
        for i in outargs:
            setattr(game.getobjbyid(gamedata[oid]["args"]["ID"]), i, outargs[i])
    id["args"].update(outargs)
def load(target):
    file = open(target, 'r')
    target = file.read()
    file.close()
    target = ast.literal_eval(target)
    for i in target:
        importobj(i)

def log(text, end="\n", flush=False):
    global logfile
    file = open(logfile+".txt", 'a')
    file.write(text+end)
    file.close()

def NULL():
    pass

class gsound:
    def __init__(self, data, game):
        self._playing = False
        self._data = data
        game.currentsounds.append(self)
    
    def play(self):
        if self._playing == True: return
        self._sound = sa.play_buffer(self._data, 2, 2, 44100)
        self._playing = True
    
    def stop(self):
        if self._playing == False: return
        self._sound.stop()
        self._playing = False
    
    def wait(self):
        if self._playing == False: return
        self._sound.wait_done()

def run():
    print("preparing log file...")
    global logfile
    global maingame
    global window
    temp = time.gmtime(time.time())
    logfile = ""
    for i in temp:
        logfile = logfile + "S" + str(i)
    print("done")
    log("Log file start!")
    log("Preparing API...")
    API = {"print": log, "HASHBASE": hashengine}
    log("Done!")
    window = tk.Tk()
    window.protocol("WM_DELETE_WINDOW", NULL)
    maingame = game
    API["HASHGAME"] = maingame
    API["SOUND"] = lambda data: gsound(data, maingame)
    log("main game initalised!")
    log("copying sounds...")
    for i in gamedata:
        i = gamedata[i]
        if i["id"] != "sound" and i["id"] != "rawsound": continue
        maingame.sounds[i["args"]["spath"]] = i["args"]["sdata"]
        print(i["args"]["spath"])
    scripts = []
    for i in gamedata:
        i = gamedata[i]
        if i["id"] != "script": continue
        i = i["args"]["code"]
        obj = script()
        obj.code = i
        scripts.append(obj)
    for i in scripts:
        maingame.startscript(lambda: i.execute(API))
    log("objects transferred!")
    gamescript = """
global HASHGAME
import time
while True:
    for i in HASHGAME._objects:
        i = HASHGAME._objects[i]
        HASHGAME.calcphysobj(i)
    HASHGAME.render()
"""
    gameloopsc = script()
    gameloopsc.code = gamescript
    maingame.startscript(lambda: gameloopsc.execute(API))
    log("game test started!!!")
    log("---------------------")

def wait():
    time.sleep(0.1)
    load("game.HEGF")
    run()

def apath(old, ext):
    return "/"

class rsound:
    def __init__(self):
        self.spath = ""
        self.sdata = b""

class sound():
    def __init__(self, new):
        self.spath = os.path.basename(new).split(".")[0]
        self.sdata = hashengine.loadsound(new)

global types
global ignoreat
global valtypes
global extypes
global attypes
global crucial
global game
win = tk.Tk()
game = hashengine.game(renderer=lambda size, cam: rend(size, cam, win, [0, 0]), sounddir="/")
crucial = ["obj",]
types = hashengine.enum({"obj": hashengine.obj, "script": script, "rawsound": rsound, "sound": lambda: sound(apath("", [("Wave files", ".wave .wav")]))})
ignoreat = ["ID", "execute", "sdata"]
"""self.position = vector2()
self.char = " "
self.ID = 0
self.gravity = 0
self.acceleration = vector2()
self.velocity = vector2()
self.friction = 0
self.collide = True
self.touch = True
self.anchored = False
self.bcolor = color3(255, 255, 255)
self.fcolor = color3()"""
attypes = {
"vector2": hashengine.vector2,
"color3": hashengine.color3,
}
threading.Thread(target=wait).start()
win.mainloop()