start:                  ;WERSJA NIEDZIAŁAJĄCA Z WIELOKROTNYM KODOWANIEM, AUTOMATYCZNYM MENU, JEST PARE NADMIAROWYCH XORÓW JUST IN CASE :>
    org 100h
    call ente ;enter
    call powitanie

koniec:
    mov ax, 4c00h
    int 21h

powitanie:
    xor ax, ax
    xor dx, dx
    mov ah, 9
    mov dx, witaj
    int 21h
    xor ax, ax
    xor dx, dx

Menu: ;Menu odpowiadające za kodowanie/wyjście
    mov ah, 1
    int 21h
    sub al, 48
    cmp al, 2
    je koniec
    cmp al, 1
    ja innywyborf
    jb innywyborf


    xor ax, ax ;wcisnieta zostala 1, czyli przechodzimy do wpisania kodu do zaszyfrowania
    call ente
    call wpisanie ;funkcja wpisujaca kod do tablicy Cezara
    call ente
    call przesuniecie ;funkcja wpisujaca przesuniecie do tablicy przesuniecia
    call ente
    call przeliczzestringa ;funkcja liczaca przesuniecie ze stringa na inta
    call modulo26 ;funkcja dzielaca modulo wartosc przesuniecia
    call Convert  ;konwersja duzych liter na male, innych znakow na spacje
    call cezar ;funkcja dodająca przesunięcie do szyfrowanego kodu i 'zapetlajaca' alfabet
    call wyswietl ;wyswietlenie zaszyfrowanego kodu
    call ente
    call zerowanietablic     ; po kazdym zaszyfrowaniua nalezy wyzerowac tablice Cezara i tablice przesuniecia + wartosc przesuniecia
                        ;   + wartosc przesuniecia po dzieleniu modulo, aby móc wielokrotnie kodowac nowe szyfry
    jmp ponowne
    ret


ponowne:
    xor ax, ax
    xor dx, dx
    mov ah, 9
    mov dx, ponowneszyfrowanie
    int 21h
    xor ax, ax
    xor dx, dx
    jmp Menu

innywyborf:
    xor ax, ax
    xor dx, dx
    mov ah, 9
    mov dx, innywybor
    int 21h
    xor ax, ax
    xor dx, dx

    jmp Menu

zerowanietablic: ;po pierwszym wpisaniu szyfru i zakodowaniu, nalezy wyzerowac tablicecezara i tabliceprzesuniecia
    xor ax, ax
    xor si, si
    xor di, di
    mov al, [iloscznakowtablicycezara]
    mov si, ax                  ;w si ilosc znakow tablicy cezara
    xor ax, ax
    mov al, [iloscznakowprzesuniecia]
    mov di, ax                  ; w di ilosc znakow tablicy przesuniecia
    xor ax, ax
    inc si
    inc di

zerowanietablic2: ;zerowanie tablicy cezara
    mov byte [tablicacezara+si],36
    dec si
    cmp si,1
    ja zerowanietablic2
    xor si, si

zerowanietablic3: ;zerowanie tablicy przesuniecia
    mov byte [tablicaprzesuniecia+di], 36
    dec di
    cmp di, 1
    ja zerowanietablic3
    xor di, di
mov byte [wynikpomodulo],0
mov word [wynik],0
    xor ax, ax
    xor bx, bx
    xor dx, dx
    xor cx, cx
    xor si, si
ret

wpisanie: ;wpisanie do tablicy cezara ciagu liter ktore chcemy zaszyfrowac
    xor ax, ax
    xor dx, dx
    mov ah, 10
    mov dx, tablicacezara
    int 21h
    mov cl, [tablicacezara+1]
    mov [iloscznakowtablicycezara], cl
    xor ax, ax
    xor dx, dx
    xor cx, cx

    ret

przesuniecie:  ;pobranie przesuniecia kodu Cezara do tablicy przesuniecia
    xor cx, cx
    xor ax, ax
    xor dx, dx
    mov ah, 10
    mov dx, tablicaprzesuniecia
    int 21h
    mov cl, [tablicaprzesuniecia+1]
    mov [iloscznakowprzesuniecia], cl
    xor cx, cx
    xor ax, ax
    xor dx, dx

    ret
przeliczzestringa: ;konwersja przesuniecia ze stringa na int
    xor di, di
    xor cx, cx
    xor ax, ax
    mov cl, [iloscznakowprzesuniecia]
    mov di, cx ; do di ilosc znakow +1 idzie
    inc di
    xor cx, cx
    xor bx,bx
    xor ax, ax
    xor dx, dx
    mov bx, 1

przeliczzestringa2: ;wlasciwe przeliczanie od tylu, czyli cyfra jednosci*1, cyfra dziesiatek*10, cyfra setek*100 itd
    mov al, [tablicaprzesuniecia+di]
    sub al, 48
    mul bx ;zwraca wartosc ostatniej cyfry-stringa na poczatku
    add word [wynik], ax  ;dodaje do wyniku - wartosci przesuniecia
    ;trzeba zwiekszyc mnoznik o 10, wynik jest zapisywany w ax
    xor dx, dx
    xor ax, ax
    mov ax, bx ;mnoznik przerzucam
    mul word [dziesiec]
    xor dx, dx
    mov bx, ax ; przerzucam z powrotem mnoznik
    xor ax, ax
    dec di
    cmp di,1
    ja przeliczzestringa2

    xor dx, dx
    xor bx, bx
    xor ax, ax
    xor di, di
    xor cx, cx
        ;ostateczny wynik intowy przesuniecia stringowego jest  w [wynik]

    ret

modulo26: ;dzielenie wyniku intowego modulo26 aby zapetlic przesuniecie
    xor bx, bx
    xor ax, ax
    xor dx, dx
    mov ax, [wynik] ;w wynik wartosc intowa przesuniecia
    div word [dzielnikalfabetu2]
    mov [wynikpomodulo], dl
    xor ax, ax
    xor dx, dx

    ret

cezar: ;Wlasciwe przesuwanie kodu o wartosc przesuniecia, wstawienie do di [iloscznakowtablicycezara]+1
    xor ax, ax
    xor bx, bx
    xor dx, dx
    xor cx, cx
    mov cl,[iloscznakowtablicycezara]
    mov DI, cx
    inc di
    xor cx, cx

cezar2: ;sprawdzenie czy spacja, jak tak to pominiecie
    cmp byte [tablicacezara+di], " "
    jne cezar3
    dec di
    cmp di, 1
    ja cezar2
    xor di, di
    xor bx, bx
    xor ax, ax
    xor cx, cx

    mov word [wynik],0
    mov byte [wynikpomodulo],0

    ret

cezar3: ;przesuniecie liter tablicy o [wynikpomodulo], zapętlanie
    xor bx, bx
    mov  bl, [wynikpomodulo]
    add byte [tablicacezara+di],bl
    cmp byte [tablicacezara+di], 'z'                        ;sprawdzenie czy wieksze od
    ja cezarprzesundopoczatku

    dec di
    cmp di, 1
    ja cezar2
    xor di, di
    xor bx, bx
    xor ax, ax
    xor cx, cx

    mov word [wynik],0
    mov byte [wynikpomodulo],0
    ret

cezarprzesundopoczatku: ;funkcja zapętla alabet, np przy przesunieciu o 2 z->b
    sub byte [tablicacezara+di], 26
    dec di
    cmp di, 1
    ja cezar2

    xor di, di
    xor bx, bx
    xor ax, ax
    xor cx, cx

    mov word [wynik],0 ;zerowanie wyniku konwersji stringa na inta, aby móc wielokrotnie kodować
    mov byte [wynikpomodulo],0 ;zerowanie wyniku dzielenia modulo do przesuniecia cezara, aby móc wielokrotnie kodować
    ret

wyswietl: ;wyswietla zakodowaną tablicę cezara
    xor ax, ax
    xor dx, dx
    mov ah, 9
    mov dx, tablicacezara+2
    int 21h

    ret

Convert:  ;Konwersja duzych na male, innych znakow na spacje, do di wrzucenie ilosci znakow tablicy cezara +1
    xor ax, ax
    xor bx, bx
    xor cx, cx
    xor dx, dx
    mov cl,[iloscznakowtablicycezara]
    xor ch, ch
    mov DI, cx
    inc di
    xor cx, cx

Convert2:;convert duzych na male, innych znakow na spacje
    cmp byte [tablicacezara+di],'a'
    jb ConverttoUpper           ;to moze byc inny znak lub duza litera
                                ;Abc Def GH+i;J
    cmp byte [tablicacezara+di],'z'
    ja ConverttoUpper            ;to moze byc inny znak lub duza litera
                                ;to mala litera
    dec di
    cmp di, 1
    ja Convert2
    xor di, di

    ret

ConverttoUpper:
    cmp byte [tablicacezara+di], 'A'
    jb Spacja                    ;to jest inny znak;

    cmp byte [tablicacezara+di],'Z'
    ja Spacja                   ; to jest inny znak
                                    ;to duza litera
    add byte[tablicacezara+di],32
    dec di
    cmp di, 1
    ja Convert2
    xor di, di

    ret


Spacja: ;wstawienie spacji zamiast innego znaku
    mov byte [tablicacezara+di], " "
    dec di
    cmp di, 1
    ja Convert2
    xor di, di

    ret



ente: ;funkcja wypisujaca enter
    xor ax, ax
    xor dx, dx
    mov ah, 9
    mov dx, ent
    int 21h
    XOR DX, DX
    XOR AX, AX

    ret

tablicacezara db 26  ;1 bajt ograniczenie ilosci znakow, 2 bajt ilosc znakow wpisanych, 3 wypelnienie, na kod
    db 0
    times 27 db "$"
ent db 10,13,"$"
iloscznakowtablicycezara db 0
tablicaprzesuniecia db 17  ;1 bajt ograniczenie ilosci znakow, na przesuniecie
        db 0; 2 bajt ilosc znakow wpisanych, 3 wypelnienie
        times 18 db "$"


iloscznakowprzesuniecia db 0
wynik dw 0
dziesiec dw 10
dzielnikalfabetu2 dw 26
wynikpomodulo db 0
innywybor dw 10,13,"Wybierz inna opcje! 1 - KODOWANIE, 2 - WYJSCIE: $"
witaj dw "Witaj w moim programie kodu Cezara. Program korzysta z funkcji modulo26 aby",10,13,"zapetlic duze przesuniecia. Nacisnij 1, a nastepnie wpisz kod do zaszyfrowania oraz przesuniecie Cezara w postaci liczby 16-bit, aby zaszyfrowac kod.",10,13,"Nacisnij 2 aby wyjsc: $"
ponowneszyfrowanie db "Zaszyfruj ponownie lub wyjdz ", 10, 13, 36