#include <Array.au3>
#include <String.au3>

Opt("GUIOnEventMode", 1)

Global $hGui = Guicreate("BrainFuck - GUI (e4)", 600, 310)
GUISetOnEvent(-3, "_Exit", $hGui)
Global $Asc2BF_Input = GUICtrlCreateEdit("", 0, 25, 250, 100, 0x00200000)
Global $Asc2BF_Output = GUICtrlCreateEdit("", 0, 125, 250, 100, 0x00200000 + 2048)

Global $BF2Asc_Input = GUICtrlCreateEdit("", 300, 25, 250, 100, 0x00200000)
Global $BF2Asc_Output = GUICtrlCreateEdit("", 300, 125, 250, 100, 0x00200000 + 2048)

GUICtrlCreateLabel("AscII To BrainFuck", 0, 8,250, 15, 1)
GUICtrlCreateLabel("BrainFuck To AscII", 300, 8,250, 15, 1)

GUICtrlCreateButton("Asc2BF", 150, 253, 100, 23)
GUICtrlSetOnEvent(-1, "__Asc2BF")
GUICtrlCreateButton("BF2Asc", 300 + 150, 253, 100, 23)
GUICtrlSetOnEvent(-1, "__BF2Asc")

GUICtrlCreateEdit("Zeichen:", 250, 25, 50, 20, 2049)
Global $Stringlen_Asc2BF_Input = GUICtrlCreateEdit("", 250, 45, 50, 20, 2049)

GUICtrlCreateEdit("Zeichen:", 250, 125, 50, 20, 2049)
Global $Stringlen_Asc2BF_Output = GUICtrlCreateEdit("", 250, 145, 50, 20, 2049)

GUICtrlCreateEdit("Zeichen:", 550, 25, 50, 20, 2049)
Global $Stringlen_BF2Asc_Input = GUICtrlCreateEdit("", 550, 45, 50, 20, 2049)

GUICtrlCreateEdit("Zeichen:", 550, 125, 50, 20, 2049)
Global $Stringlen_BF2Asc_Output = GUICtrlCreateEdit("", 550, 145, 50, 20, 2049)

GUICtrlCreateLabel("Kompression:", 0, 230, 150, 17, 1)
Global $Kompression_Asc2BF = GUICtrlCreateLabel("", 150, 230, 100, 17, 1)
GUICtrlCreateLabel("Kompression:", 300, 230, 150, 17, 1)
Global $Kompression_BF2Asc = GUICtrlCreateLabel("", 450, 230, 100, 17, 1)

GUICtrlCreateLabel("v1 bis v3", 40, 257, 50, 90)
Global $Version_Input = GUICtrlCreateEdit("1", 95, 255, 50, 20, 1)

GUICtrlCreateLabel("------------------------ Alle hier verwendeten Funktionen sind von BugFix. ------------------------", 0, 285, 600, 16,1)

GUISetState(@SW_SHOW)

While 1
	Sleep(10)
	_Stringlen_Label(StringLen(GUICtrlRead($Asc2BF_Input)), StringLen(GUICtrlRead($Asc2BF_Output)), StringLen(GUICtrlRead($BF2Asc_Input)), Stringlen(GUICtrlRead($BF2Asc_Output)), $Stringlen_Asc2BF_Input, $Stringlen_Asc2BF_Output, $Stringlen_BF2Asc_Input, $Stringlen_BF2Asc_Output)
	_Testchen($Version_Input)
WEnd

Func _Exit()
Exit
EndFunc

Func _Testchen($a)
	Local $b = GUICtrlRead($a)
	Local $c = StringLen($b)
	If $b <> 1 And $b <> 2 And $b <> 3 Or $c <> 1 Then GUICtrlSetData($Version_Input,Random(1,3,1))
EndFunc

Func _Stringlen_Label($a,$b,$c,$d, $a1, $b1, $c1, $d1)

If $a <> Int(GUICtrlRead($a1)) Then GUICtrlSetData($a1, $a)
If $b <> Int(GUICtrlRead($b1)) Then GUICtrlSetData($b1, $b)
If $c <> Int(GUICtrlRead($c1)) Then GUICtrlSetData($c1, $c)
If $d <> Int(GUICtrlRead($d1)) Then GUICtrlSetData($d1, $d)

Local $div_b_a = $b/$a
Local $div_d_c = $d/$c

If Not StringInStr($div_b_a, "IND") Then
If GUICtrlRead($Kompression_Asc2BF) <> Round($div_b_a, 2)*100 & " %" Then GUICtrlSetData($Kompression_Asc2BF, Round($div_b_a,2)*100 & " %")
EndIf

If Not StringInStr($div_d_c, "IND") Then
If GUICtrlRead($Kompression_BF2Asc) <> Round($div_d_c, 2)*100 & " %" Then GUICtrlSetData($Kompression_BF2Asc, Round($div_d_c,2)*100 & " %")
EndIf

EndFunc

Func __Asc2BF()
	Local $a = GUICtrlRead($Asc2BF_Input)
	If $a <> "" Then
	GUICtrlSetData($Asc2BF_Output, "Wird berechnet ...")
	Switch GUICtrlRead($Version_Input)
		Case 1
	GUICtrlSetData($Asc2BF_Output, _AsciiToBFcode_1($a))
Case 2
	GUICtrlSetData($Asc2BF_Output, _AsciiToBFcode_2($a))
Case 3
	GUICtrlSetData($Asc2BF_Output, _AsciiToBFcode_3($a))
EndSwitch
EndIf
EndFunc

Func __BF2Asc()
	Local $a = GUICtrlRead($BF2Asc_Input)
	If $a <> "" Then
	GUICtrlSetData($BF2Asc_Output, "Wird berechnet ...")
	GUICtrlSetData($BF2Asc_Output, _BFtextInterpreter($a))
	EndIf
EndFunc

#cs
#####################################
Folgende Funktionen sind von BugFix
#####################################
#ce

Func _BFtextInterpreter($sBFcode)
	Local $aCode = StringSplit(StringStripWS($sBFcode, 8), '', 2)
	Local $sOut = '', $index = 0, $count, $iLoop = -1
	Local $a[30000], $pt = 0
	Do
		If $index < UBound($aCode) -1 Then
			$count = __CountEvenNeighbour($aCode, $index)
		Else
			$count = 0
		EndIf
		Switch $aCode[$index]
			Case '>'
				$pt += 1 + $count
				$index += 1 + $count
			Case '<'
				$pt -= (1 + $count)
				$index += 1 + $count
			Case '+'
				$a[$pt] += 1 + $count
				$index += 1 + $count
			Case '-'
				$a[$pt] -= 1 + $count
				$index += 1 + $count
			Case '['
				$iLoop = $index +1
				$index += 1 + $count
			Case ']'
				If $a[$pt] = 0 Then
					$iLoop = -1
					$index += 1 + $count
				Else
					$index = $iLoop
				EndIf
			Case '.'
				$sOut &= Chr($a[$pt])
				$index += 1
			Case ',' ; erwartet Input von Standardeingabe
;~ 	 			$a[$pt] = Asc('Input')
;~ 	 			$index += 1
		EndSwitch
	Until $index = UBound($aCode)
	Return $sOut
EndFunc  ;==>_BFtextInterpreter

Func __CountEvenNeighbour(ByRef $aCode, $iStart)
	Local $counter = 0
	While $aCode[$iStart +$counter +1] == $aCode[$iStart]
		$counter += 1
		If $iStart +$counter +1 = UBound($aCode) Then ExitLoop
	WEnd
	Return $counter
EndFunc  ;==>__CountEvenNeighbour

Func _AsciiToBFcode_3($sString) ; Version 3 (Neuste Version)
	Local $aString = StringSplit($sString, '', 2)
	Local $aWork[UBound($aString)][3], $aRounded[1][2]
	; === ASCII-Werte ermitteln und die zugehörigen gerundeten Zehner-ASCII-Werte
	For $i = 0 To UBound($aString) -1
		$aWork[$i][0] = Asc($aString[$i])            ; ASCII-Wert des Zeichens
		$aWork[$i][1] = Round($aWork[$i][0] /10) *10 ; auf Zehnerwert auf/abgerundeter ASCII-Wert
		$aWork[$i][2] = $i                           ; Position im Ausgangsstring
	Next
	; === nach ASCII-Werten aufsteigend sortieren
	_ArraySort($aWork)
	; === gerundete Zehner-ASCII-Werte zusammenfassen
	$aRounded[0][0] = $aWork[0][1]                   ; gerundeter Zehner-ASCII-Wert
	$aRounded[0][1] = $aWork[0][1]                   ; momentan genutzter Wert
	For $i = 0 To UBound($aWork) -1
		If $i < UBound($aWork) -1 Then
			If $aWork[$i][1] <> $aWork[$i+1][1] Then
				ReDim $aRounded[UBound($aRounded)+1][2]
				$aRounded[UBound($aRounded)-1][0] = $aWork[$i+1][1]
				$aRounded[UBound($aRounded)-1][1] = $aWork[$i+1][1]
			EndIf
		EndIf
	Next
	; === wieder nach Reihenfolge Zeichen sortieren
	_ArraySort($aWork, 0, 0,0,2)
	; === je eine Zelle auf einen einmal vorkommenden gerundeten Zehner-ASCII-Wert setzen
	Local $sBF = '>++++++++++['                               ; Faktor 10 vor der Schleife erstellen
	For $i = 0 To UBound($aRounded) -1
		$sBF &= '>' & _StringRepeat('+', $aRounded[$i][0]/10) ; Faktor für Zehner-Multiplikation
	Next
	$sBF &= _StringRepeat('<', UBound($aRounded)) & '-]'      ; zurück auf Schleifenzähler und dekrementieren
	$sBF &= '>'                                               ; Pointer auf erste Wertezelle
	Local $index, $index_last = 0, $step = 0, $diff = 0, $nextStep
	For $i = 0 To UBound($aString) -1                         ; durch Eingabestring iterieren
		$index = _ArraySearch($aRounded, $aWork[$i][1])
		$diff = $index - $index_last
		$index_last = $index
		Select
			Case $diff < 0
				$nextStep = _StringRepeat('<', Abs($diff))
			Case 0
				$nextStep = ''
			Case Else
				$nextStep = _StringRepeat('>', $diff)
		EndSelect
		$sBF &= $nextStep
		$diff = $aWork[$i][0] - $aRounded[$index][1]          ; Differenz zw. tatsächlichem Wert und zuletzt genutztem Wert
		; === Zelle unter Pointer um $diff in/dekrementieren, Zeichen ausgeben
		Select
			Case $diff < 0
				$nextStep = _StringRepeat('-', Abs($diff))
			Case 0
				$nextStep = ''
			Case Else
				$nextStep = _StringRepeat('+', $diff)
		EndSelect
		$aRounded[$index][1] += $diff                        ; zuletzt genutzten Wert in Zelle aktualisieren
		$sBF &= $nextStep & '.'
	Next
	Return $sBF
EndFunc  ;==>_AsciiToBFcode

Func _AsciiToBFcode_2($sString) ; Version 2
	Local $aString = StringSplit($sString, '', 2)
	Local $aWork[UBound($aString)][3], $aRounded[1][2]
	; === ASCII-Werte ermitteln und die zugehörigen gerundeten Zehner-ASCII-Werte
	For $i = 0 To UBound($aString) -1
		$aWork[$i][0] = Asc($aString[$i])            ; ASCII-Wert des Zeichens
		$aWork[$i][1] = Round($aWork[$i][0] /10) *10 ; auf Zehnerwert auf/abgerundeter ASCII-Wert
		$aWork[$i][2] = $i                           ; Position im Ausgangsstring
	Next
	; === nach ASCII-Werten aufsteigend sortieren
	_ArraySort($aWork)
	; === gerundete Zehner-ASCII-Werte zusammenfassen
	$aRounded[0][0] = $aWork[0][1]
	$aRounded[0][1] = 1
	For $i = 0 To UBound($aWork) -1
		If $i < UBound($aWork) -1 Then
			If $aWork[$i][1] <> $aWork[$i+1][1] Then
				ReDim $aRounded[UBound($aRounded)+1][2]
				$aRounded[UBound($aRounded)-1][0] = $aWork[$i+1][1]
				$aRounded[UBound($aRounded)-1][1] = 1
			Else
				$aRounded[UBound($aRounded)-1][1] += 1
			EndIf
		EndIf
	Next
	; === wieder nach Reihenfolge Zeichen sortieren
	_ArraySort($aWork, 0, 0,0,2)
	; === je eine Zelle auf einen einmal vorkommenden gerundeten Zehner-ASCII-Wert setzen
	Local $sBF = '>++++++++++['                               ; Faktor 10 vor der Schleife erstellen
	For $i = 0 To UBound($aRounded) -1
		$sBF &= '>' & _StringRepeat('+', $aRounded[$i][0]/10) ; Faktor für Zehner-Multiplikation
	Next
	$sBF &= _StringRepeat('<', UBound($aRounded)) & '-]'      ; zurück auf Schleifenzähler und dekrementieren
	$sBF &= '>'                                               ; Pointer auf erste Wertezelle
	Local $index, $index_last = 0, $step = 0, $diff = 0, $nextStep, $backStep, $lastback, $nextIsSame = False
	For $i = 0 To UBound($aString) -1                         ; durch Eingabestring iterieren
		$index = _ArraySearch($aRounded, $aWork[$i][1])
		$diff = $index - $index_last
		$index_last = $index
		Select
			Case $diff < 0
				$nextStep = _StringRepeat('<', Abs($diff))
			Case 0
				$nextStep = ''
			Case Else
				$nextStep = _StringRepeat('>', $diff)
		EndSelect
		$sBF &= $nextStep
		$diff = $aWork[$i][0] - $aWork[$i][1]                 ; Differenz zw. tatsächlichem Wert und Round-Wert
		; === Zelle unter Pointer um $diff in/dekrementieren, Zeichen ausgeben, Wert zurücksetzen
		; === nur wenn Folgezeichen <> aktuellem Zeichen
		If Not $nextIsSame Then
			Select
				Case $diff < 0
					$nextStep = _StringRepeat('-', Abs($diff))
					$backStep = _StringRepeat('+', Abs($diff))
				Case 0
					$nextStep = ''
				Case Else
					$nextStep = _StringRepeat('+', $diff)
					$backStep = _StringRepeat('-', $diff)
			EndSelect
			$lastback = $backStep
		EndIf
		$aRounded[$index][1] -= 1
		; === wenn Zelle letztmalig verwendet wurde, Wert in Zelle nicht mehr zurücksetzen
		If $aRounded[$index][1] = 0 Then $backStep = ''
		; === wenn Folgezeichen identisch, dann Wert auch nicht zurücksetzen
		If ($i < UBound($aString) -2) And ($aString[$i] == $aString[$i+1]) Then
			$nextIsSame = True
			$lastback = $backStep
			$backStep = ''
		ElseIf ($i < UBound($aString) -2) And ($aString[$i] <> $aString[$i+1]) Then
			$nextIsSame = False
			$backStep = $lastback
		EndIf
		$sBF &= $nextStep & '.' & $backStep
	Next
	Return $sBF
EndFunc  ;==>_AsciiToBFcode_2

Func _AsciiToBFcode_1($sString) ; Version 1
    Local $aString = StringSplit($sString, '', 2)
    Local $aWork[UBound($aString)][3], $sUniqueRounded
    ; === ASCII-Werte ermitteln und die zugehörigen gerundeten Zehner-ASCII-Werte
    For $i = 0 To UBound($aString) -1
        $aWork[$i][0] = Asc($aString[$i])            ; ASCII-Wert des Zeichens
        $aWork[$i][1] = Round($aWork[$i][0] /10) *10 ; auf Zehnerwert auf/abgerundeter ASCII-Wert
        $aWork[$i][2] = $i                           ; Position im Ausgangsstring
    Next
    ; === nach ASCII-Werten aufsteigend sortieren
    _ArraySort($aWork)
    ; === gerundete Zehner-ASCII-Werte zusammenfassen
    $sUniqueRounded = $aWork[UBound($aWork)-1][1]
    For $i = UBound($aWork) -1 To 0 Step -1
        If $i > 0 Then
            If $aWork[$i][1] <> $aWork[$i-1][1] Then $sUniqueRounded = $aWork[$i-1][1] & ',' & $sUniqueRounded
        EndIf
    Next
    ; === wieder nach Reihenfolge Zeichen sortieren
    _ArraySort($aWork, 0, 0,0,2)
    Local $aUnique = StringSplit($sUniqueRounded, ',', 2) ; Array mit gerundeten Zehner-ASCII-Werten
    ; === je eine Zelle auf einen einmal vorkommenden gerundeten Zehner-ASCII-Wert setzen
    Local $sBF = '>++++++++++['                           ; Faktor 10 vor der Schleife erstellen
    For $i = 0 To UBound($aUnique) -1
        $sBF &= '>' & _StringRepeat('+', $aUnique[$i]/10) ; Faktor für Zehner-Multiplikation
    Next
    $sBF &= _StringRepeat('<', UBound($aUnique)) & '-]'   ; zurück auf Schleifenzähler und dekrementieren
    $sBF &= '>'                                           ; Pointer auf erste Wertezelle
    Local $index, $index_last = 0, $step = 0, $diff = 0, $nextStep, $backStep
    For $i = 0 To UBound($aString) -1
        $index = _ArraySearch($aUnique, $aWork[$i][1])
        $diff = $index - $index_last
        $index_last = $index
        Select
            Case $diff < 0
                $nextStep = _StringRepeat('<', Abs($diff))
            Case 0
                $nextStep = ''
            Case Else
                $nextStep = _StringRepeat('>', $diff)
        EndSelect
        $sBF &= $nextStep
        $diff = $aWork[$i][0] - $aWork[$i][1]            ; Differenz zw. tatsächlichem Wert und Round-Wert
        ; === Zelle unter Pointer um $diff in/dekrementieren, Zeichen ausgeben, Wert zurücksetzen
        Select
            Case $diff < 0
                $nextStep = _StringRepeat('-', Abs($diff))
                $backStep = _StringRepeat('+', Abs($diff))
            Case 0
                $nextStep = ''
            Case Else
                $nextStep = _StringRepeat('+', $diff)
                $backStep = _StringRepeat('-', $diff)
        EndSelect
        If $i = UBound($aString) -1 Then $backStep = ''
        $sBF &= $nextStep & '.' & $backStep
    Next
    Return $sBF
EndFunc  ;==>_AsciiToBFcode_1