# 1) Testapplicatie
class ShiftRegister:
    def __init__(self, ds_pin=DS, shcp_pin=SHCP, stcp_pin=STCP, mr_pin=MR, oe_pin=OE):
        self.ds_pin = ds_pin
        self.shcp_pin = shcp_pin
        self.stcp_pin = stcp_pin
        self.mr_pin = mr_pin
        self.oe_pin = oe_pin
        self.pins = [self.ds_pin, self.shcp_pin, self.stcp_pin, self.mr_pin, self.oe_pin]
        for i in range(len(self.pins)):
            GPIO.setup(self.pins[i], GPIO.OUT)
            GPIO.output(self.pins[i], GPIO.LOW)
        GPIO.output(self.pins[3], GPIO.HIGH)

    def write_bit(self, value):
        if isinstance(value, int) and 0 <= value <= 1:
            if value == 1:
                GPIO.output(self.ds_pin, GPIO.HIGH)
            else:
                GPIO.output(self.ds_pin, GPIO.LOW)
            GPIO.output(self.shcp_pin, GPIO.LOW)
            time.sleep(1 / FREQ / 2)
            GPIO.output(self.shcp_pin, GPIO.HIGH)
            time.sleep(1 / FREQ / 2)
        else:
            log.error("Een verkeerde waarde werd opgegeven!")
            raise ValueError('Een verkeerde waarde werd doorgegeven.')


    def copy_to_storage_register(self):
        GPIO.output(self.stcp_pin, GPIO.LOW)
        time.sleep(1 / FREQ / 2)
        GPIO.output(self.stcp_pin, GPIO.HIGH)
        time.sleep(1 / FREQ / 2)

    def write_byte(self, value):
        prefix = ''
        for i in range(8-len(str(value))):
            prefix += '0'
        finbyte = prefix + value
        for i in range(len(finbyte)):
            self.write_bit(int(finbyte[i]))
        self.copy_to_storage_register()

    def reset_shift_register(self):
        GPIO.output(self.pins[3], GPIO.LOW)
        GPIO.output(self.pins[3], GPIO.HIGH)

    def reset_storage_register(self):
        GPIO.output(self.pins[3], GPIO.LOW)
        GPIO.output(self.pins[2], GPIO.HIGH)
        GPIO.output(self.pins[3], GPIO.HIGH)
        GPIO.output(self.pins[2], GPIO.LOW)


def shiftreg_demo():
    ss = ShiftRegister()
    value = 1
    while value < 0xff:
        ss.write_byte(bin(value)[2:])
        ss.copy_to_storage_register()
        time.sleep(1)
        value <<= 1

class SevenSegment:
    def __init__(self):
        self.shreg = ShiftRegister()
        for i in range(0,len(PIN_DISPLAY_CATHODES)):
            GPIO.setup(PIN_DISPLAY_CATHODES[i], GPIO.OUT)
            GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)


    def show_segments(self):
        for i in range(10):
            self.shreg.write_byte(bin(SEGMENTS[i])[2:])
            time.sleep(1)


    def set_raw_data(self, value):
        if type == 0:
            value = str(value)[11:16]
            print(value)
            UenM = value.replace(":", "")
            teller = 0
            while teller <= 2500:
                for i in range(4):
                    if i == 1:
                        GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                        time.sleep(0.001)
                        self.show_number(int(UenM[i]), True)
                        GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
                    else:
                        GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                        time.sleep(0.001)
                        self.show_number(int(UenM[i]))
                        GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
                    teller += 1
        elif type == 1:
            value = str(value)[-2:]
            print(value)
            S = value.replace(":", "")
            teller = 0
            while teller <= 5000:
                for i in range(2):
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                    time.sleep(0.001)
                    self.show_number(int(S[i]))
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
                    teller += 1
        elif type == 2:
            value = str(value)[5:10]
            print(value)
            MenD = value.replace("-", "")
            teller = 0
            while teller <= 2500:
                for i in range(4):
                    if i == 1:
                        self.show_number(int(MenD[i]), True)
                    else:
                        GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                        time.sleep(0.001)
                        self.show_number(int(MenD[i]))
                        GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
                    teller += 1
        elif type == 3:
            Y = str(value)[:5]
            print(Y)
            teller = 0
            while teller <= 2500:
                for i in range(4):
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                    time.sleep(0.001)
                    self.show_number(int(Y[i]))
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
                    teller += 1
        else:
            log.error("Een verkeerde type value werd doorgegeven!")
            raise ValueError("Een verkeerde type werd doorgegeven.")


    def set_value(self, value=random.randint(0,10000), with_dp=False):
        list_value = list(str(value))
        for i in range(0, len(list_value)):
            if len(list_value) == 4:
                if i == 0:
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                    time.sleep(0.001)
                    self.show_number(int(list_value[i]), True)
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
                else:
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                    time.sleep(0.001)
                    self.show_number(int(list_value[i]))
                    GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)
            else:
                GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.LOW)
                time.sleep(0.001)
                self.show_number(int(list_value[i]))
                GPIO.output(PIN_DISPLAY_CATHODES[i], GPIO.HIGH)


    def show_number(self, value, with_dp=False):
        if with_dp == True:
            byte = SEGMENTS[value] | DP
        else:
            byte = SEGMENTS[value]
        self.shreg.write_byte(bin(byte)[2:])