# -*- coding: utf-8 -*-
from copy import deepcopy

class Bt:
    pass

class Byte(Bt):
    def __init__(self):
        self.__status = 7 # Status 0 ist voll
        self.__folgBit=ByteEnde()
        for i in range(7):
            self.__folgBit = self.__folgBit.neuBit()
        print("1-Byte positiv ohne Überlaufschutz, Initialwert:",self.getByte(),"Maximalwert: 127")
    def getStatus(self):
        return self.__status
    def dec(self):
        self.__status += 1
        self.__folgBit.dec()
##        if self.__status > -1:
##            self.__status += 1
##            self.__folgBit.dec()
##            return True
##        else:
##            return False
    def inc(self):
        self.__status -= 1
        self.__folgBit.inc()
##        if self.__status < 8:
##            self.__status -= 1
##            self.__folgBit.inc()
##            return True
##        else:
##            return False
    def getByte(self):
        r1 = self.__folgBit.getBits([])
        r2 = []
        for e in r1:
            r2.append(str(e))
        r2 = "".join(r2)
        return r2
    def getBits(self):
        return self.__folgBit.getBits([])

class Speicher(Bt):
    def __init__(self,doppelbit,name=""):     # das erste Bit wird für +/- eingesetzt
        self.__bit=doppelbit-1        # bit-1 steht als Speicher zur Verfügung
        if doppelbit < 4:
            self.__bit = 3      # mindestens aber 2**3 Bit
        self.__status = 0 # Status (2**self.__bit)/2-1 und -(2**self.__bit)/2+1 ist voll
        self.__flag="x"
        self.__folgBit=ByteEnde()
        for i in range(self.__bit):
            self.__folgBit = self.__folgBit.neuBit()
        self.__name=name
        if name!="":
            print(self.__name,"\t2*"+str(self.__bit)+"-bit-Speicher mit Überlaufschutz: min:",int(-(2**self.__bit)+1),"max:",int(2**self.__bit)-1,"Anfangszustand:",self.getByte())
    def getName(self):
        return self.__name
    def initialwert(self):
        self.__status = 0
        self.__flag = 0
        self.__folgBit.initialwert()
    def getStatus(self):
        return self.__status
    def getFlag(self):
        return self.__flag
    def tst(self):
        if self.__status == 0:
            return False
        else:
            return True
    def dec(self):
        if self.__status > 0:
            self.__status -= 1
            if self.__status == 0:
                self.__flag = "0"
            self.__folgBit.dec()
            return True
        elif self.__status < 1 and self.__status > -(2**self.__bit)+1:
            self.__status -= 1
            if self.__status<0:
                self.__flag="n"
            self.__folgBit.inc()
            return True
        else:
            return False
    def inc(self):
        if self.__status < (2**self.__bit)-1 and self.__status > -1:
            self.__status += 1
            if self.__status > 0:
                self.__flag = "p"
            self.__folgBit.inc()
            return True
        elif self.__status < 0:
            self.__status +=1
            if self.__status == 0:
                self.__flag = "0"
            self.__folgBit.dec()
            return True            
        else:
            return False
    def getByte(self):
        if self.__status < 0:
            r1 = self.__folgBit.getBits([1])
        else:
            r1 = self.__folgBit.getBits([0])
        r2 = []
        for e in r1:
            r2.append(str(e))
        r2 = "".join(r2)
        return r2
    def getBits(self):
        return [self.__status,self.__folgBit.getBits([])]
    def setBits(self,status,bt):
        self.__status = status
        self.__folgBit.setBits(bt)
        
    
class Bit(Bt):
    def __init__(self,folgBit):
        self.__folgBit=folgBit
        self.inhalt = "x"
    def initialwert(self):
        self.inhalt=0
        self.__folgBit.initialwert()
    def inc(self):
        self.inhalt = (self.inhalt+1)%2
        if self.inhalt==0:
            self.__folgBit.inc()
    def dec(self):
        self.inhalt = (self.inhalt+1)%2
        if self.inhalt==1:
            self.__folgBit.dec()
    def getBits(self,bt):
        bt.append(self.inhalt)
        return self.__folgBit.getBits(bt)
    def setBits(self,bt):
        self.inhalt=bt.pop(0)
        self.__folgBit.setBits(bt)
    def neuBit(self):        
        self.__folgBit = self.__folgBit.neuBit()
        return self

class ByteEnde(Bt):
    def __init__(self):
        pass
    def initialwert(self):
        pass
    def neuBit(self):
        return Bit(self)
    def getBits(self,bt):
        return bt
    def setBits(self,bt):
        pass
    def dec(self):
        pass
    def inc(self):
        pass


### Speicher-Aktionen
def loadi(wert,nr,folge):
    ac.initialwert()
    for i in range(wert):
        ac.inc()
    ausdruck("loadi "+str(wert),nr)
    programm(folge)

def load(speicher,nr,folge):
    x = deepcopy(speicher.getBits())
    ac.setBits(x[0],x[1])
    ausdruck("load  "+speicher.getName(),nr)
    programm(folge)

def store(speicher,nr,folge):
    speicher.initialwert()
    x = deepcopy(ac.getBits())
    speicher.setBits(x[0],x[1])
    ausdruck("store "+speicher.getName(),nr)
    programm(folge)

def jmp(stelle,nr,folge):
    ausdruck("jmp   "+str(stelle),nr)
    programm(stelle) 

def jmpz(stelle,nr,sonst):
    if ac.getStatus() == 0: 
        ausdruck("jmpz  "+str(stelle),nr)
        programm(stelle)
    else:
        ausdruck("jmpz --\t",nr)
        programm(sonst)     

def jmpp(stelle,nr,sonst):
    if ac.getStatus() > 0:
        ausdruck("jmpp  "+str(stelle),nr)
        programm(stelle) 
    else:
        ausdruck("jmpp --\t",nr)
        programm(sonst)      

def jmpn(stelle,nr,sonst):
    if ac.getStatus() < 0:
        ausdruck("jmpn  "+str(stelle),nr)
        programm(stelle) 
    else:
        ausdruck("jmpn --\t",nr)
        programm(sonst)      

def hlt(nr):
    ausdruck("hlt\t",nr)


### weitere Funktionen
def fuegeEin(speicher,wert):
    print("Füge ein",wert)
    for i in range(wert):
        speicher.inc()
        #print(speicher.getBits())
    print(speicher.getByte())
        
def entferne(speicher,wert):
    print("entferne",wert)
    for i in range(wert):
        speicher.dec()
        #print(speicher.getBits())
    print(speicher.getByte())

### Darstellung
def starte():
    print("\nProgramm:")                                                                # Registerprogramm
    for e in prg:
        print(e)
    print("Befehl\t\tBZ\t  AC\t\tFlag\t Zelle 10\t Zelle 11\t Zelle 12\t Zelle 13")     # Kopfzeile
    ausdruck("Nicht initial.","x")                                                      # erste Zeile: nicht initialisiert
    programm(0)                                                                         # Einstieg in das Programm

def ausdruck(befehl,bz):
    print(befehl,"\t",bz,"\t",ac.getByte(),"\t",ac.getFlag(),"\t",z0.getByte(),"\t",z1.getByte(),"\t",z2.getByte(),"\t",z3.getByte())
    
### Programm
prg=["0\tloadi\t3","1\tstore\tZelle 10","2\tloadi\t4","3\tstore\tZelle 11","4\tload\tZelle 10","5\tjmpz\t10","6\tjmpp\t8","7\tjmpn\t8","8\tloadi\t0","9\tjmp\t5","10\thlt"]
def programm(nr="x"):
    if nr=="x":  starte()                               #   Registerprogramm
    elif nr==0:  loadi(3,nr,folge=1)                    #   0   loadi   3
    elif nr==1:  store(z0,nr,folge=2)                   #   1   store   Zelle 10
    elif nr==2:  loadi(4,nr,folge=3)                    #   2   loadi   4
    elif nr==3:  store(z1,nr,folge=4)                   #   3   store   Zelle 11
    elif nr==4:  load(z0,nr,folge=5)                    #   4   load    Zelle 10
    elif nr==5:  jmpz(10,nr,sonst=6)                    #   5   jmpz    10
    elif nr==6:  jmpp(8,nr,sonst=7)                     #   6   jmpp    8
    elif nr==7:  jmpn(8,nr,sonst=8)                     #   7   jmpn    8
    elif nr==8:  loadi(0,nr,folge=9)                    #   8   loadi   0
    elif nr==9:  jmp(5,nr,folge=5)                      #   9   jmp     5
    elif nr==10: hlt(nr)                                #   10  hlt
    else:
        pass

### Einrichtung der Register
ac=Speicher(8,"AC")
z0=Speicher(8,"Zelle 10")
z1=Speicher(8,"Zelle 11")
z2=Speicher(8,"Zelle 12")
z3=Speicher(8,"Zelle 13")

### Programmaufruf
programm() # stellt bei den Befehlen die Register dar

### Überlege
# wie müssten die Befehle add sp, addi wert, sub sp, subi wert, mult sp, multi wert, div sp, divi wert, mod sp, modi wert nachgebaut werden?
# sind entsprechende Befehle im Programmtext schon vorhanden?