from uuid import uuid4 as uuidv4

class Indexer():
    def __init__(self,name="Indexer"):
        self.items = {}
        self.order = []
        self.name = name

    def __getitem__(self,index):
        if type(index) ==  int:
            if len(self.order) > index:
                return self.items[self.order[index]]
            else:
                return None
        if type(index) == str:
            if index in self.items:
                return self.items[index]
            else:
                return None
    def __setitem__(self,index,item):
        if type(index) == int:
            try:
                if len(self.order)-1 >= index:
                    self.items[self.order[index]] = item
            except Exception as e:
                print(e)
                return False
                
        elif type(index) == str:
            try:
                if item in self.items:
                    self.items[index] = item
            except Exception as e:
                print(e)
                return False

    def spawn(self,item):
        tid = str(uuidv4())
        self.items[tid] = item
        self.order.append(tid)
        return tid

    def kill(self,index):
        if type(index) ==  int:
            if len(self.order) > index:
                del self.items[self.order[index]]
                del self.order[index]
                return True
            else:
                return False
        if type(index) == str:
            if index in self.items:
                del self.items[index]
                del self.order[self.order.index(index)]
                return True
            else:
                return False

class Process():
    def __init__(self,index_handle,item_handle,name="Process"):
        self.index_handle = index_handle
        self.item_handle = item_handle
        self.name = name

class Handler():
    def __init__(self,indexers=Indexer(),processes=Indexer(),name="Handler"):
        self.indexers = indexers
        self.processes = processes
        self.name = name
        
    def process(self):
        for o in self.indexers.order:#k,i
            #print(o)
            for p in self.processes.order:#n,p
                self.indexers[o] = self.processes[p].index_handle(self.indexers[o])
                for h in self.indexers[o].order:#h,j
                    #print(h)
                    #print (str(o)+"\n"+str(h))
                    self.indexers[o][h] = self.processes[p].item_handle(self.indexers[o][h])
        return True


class Event():
    def __init__(self,name="Event"):
        self.name = name
        self.actions = Indexer()
        self.order = []
        self.eid = str(uuidv4())
    def bind(self,action):
        return self.actions.spawn(action)
    def release(self,iid):
        self.actions.kill(iid)
    def vacate(self):
        self.actions = Indexer()
    def trigger(self,eg):
        for i in self.actions.order:
            a = self.actions[i]
            a.trigger(i,eg)

class Action():
    def __init__(self,mthd,name="Action"):
        self.mthd =  mthd
        self.name = name
        self.bindings = Indexer()

    def bind(self,event):
        iid = event.bind(self)
        self.bindings[iid] = {event: event, iid: iid}

    def detach(self,eid):
        self.bindings[eid].event.release(self.bindings[eid].iid)
        del self.bindings[event.eid]

    def uproot(self):
        for k,v in self.bindings:
            v.event.release(k)
        self.bindings = {}
        
    def trigger(self,index,eg):
        #try:
            self.mthd(index,eg)
        #except Exception as e:
        #    print(e)