sys_exit        equ     1
sys_write       equ     4
stdout          equ     1
stdin           equ     0

%macro turn 0
  add r8b,BYTE 1
  cmp r8b,BYTE 42
  jne %%inc_mod_exit_
  mov r8b,BYTE 0
  %%inc_mod_exit_:

  mov dl,r8b
  mov cl,33

  ; sprawdz czy R jest w dowolnej pozycji obrotowej:
  cmp dl,cl
  je turn_L

  mov cl,27
  cmp dl,cl
  je turn_L

  mov cl,35
  cmp dl,cl
  je turn_L

  jmp exit_turn             ; R nie jest w pozycji obrotowej

  turn_L:
  add r12b,BYTE 1
  cmp r12b,BYTE 42
  jne %%inc_mod_exit
  mov r12b,BYTE 0
  %%inc_mod_exit:

  exit_turn:
%endmacro

%macro print 2
  mov rdi,%1
  mov rsi,%2
  call _print
%endmacro

%macro rot_Q_1 2
  mov r11b,%1
  sub r11b,%2
  sub %1,%2

  cmp r11,90
  jle %%le
  sub %1,42
  jmp %%return
  %%le:
  cmp r11,49
  jge %%return
  add %1,42
  %%return:
%endmacro

%macro rot_Q 2
  mov r11b,%1
  add r11b,%2
  add %1,%2

  cmp r11,90
  jle %%le
  sub %1,42
  jmp %%return
  %%le:
  cmp r11,49
  jge %%return
  add %1,42
  %%return:
%endmacro

%macro rot_1_R 1 ;przyjmuje znak
  xor r11b, r11b
  %%loop:
  mov al,r11b
  movzx rcx, al
  mov al,[R + rcx]
  add r11,1
  cmp al,%1
  jne %%loop
  mov %1,r11b
  add %1,48
%endmacro

%macro rot_1_L 1 ;przyjmuje znak
  xor r11b, r11b
  %%loop:
  mov al,r11b
  movzx rcx, al
  mov al,[L + rcx]
  add r11,1
  cmp al,%1
  jne %%loop
  mov %1,r11b
  add %1,48
%endmacro

%macro rot_R 1 ;przyjmuje adres znaku
  sub %1,49
  movzx rcx, %1
  mov %1,[R + rcx]
%endmacro

%macro rot_R_ 1
  sub %1,49
  movzx rcx, %1
  mov %1,[R_ + rcx]
%endmacro

%macro rot_L_ 1
  sub %1,49
  movzx rcx, %1
  mov %1,[L_ + rcx]
%endmacro

%macro rot_L 1    ;przyjmuje adres znaku
  sub %1,49
  movzx rcx, %1
  mov %1,[L + rcx]
%endmacro

%macro rot_T 1 ;przyjmuje  znaku
  sub %1,49
  movzx rcx, %1
  mov %1,[T + rcx]
%endmacro

%macro read_arg 3
  mov rsi,[rsp + %1]
  xor rax,rax

  %%arg_loop:
    mov r14b,[rsi+rax]

    cmp r14b,91
    jge %%end_arg_loop

    cmp r14b,48
    jle %%end_arg_loop

    mov [%2+rax],r14b
    add rax,1

    cmp rax,%3
    jg %%end_arg_loop
    jmp %%arg_loop
  %%end_arg_loop:
  cmp r14b,0
  jz %%correct
  xor rax,rax
  %%correct:
%endmacro

section .data

newline         db     0xA

section .bss
  input resb 4096
  output resb 4096
  L resb 48
  R resb 48
  T resb 48
  KEY resb 4096
  R_ resb 48
  L_ resb 48

section .text
        global  _start

_start:

pop rcx
cmp rcx,2
jle error
push rcx

read_arg 16,L,42
cmp rax,42
jne error

read_arg 24,R,42
cmp rax,42
jne error

read_arg 32,T,42
cmp rax,42
jne error

read_arg 40,KEY,2
cmp rax,2
jne error

mov r8b,48
loop_R_:
add r8b,1
cmp r8b,91
je end_loop_R_
mov r12b,r8b
rot_1_R r12b
movzx rax,r8b
sub rax,49
mov [R_ + rax],BYTE r12b
jmp loop_R_
end_loop_R_:

mov r8b,48
loop_L_:
add r8b,1
cmp r8b,91
je end_loop_L_
mov r12b,r8b
rot_1_L r12b
movzx rax,r8b
sub rax,49
mov [L_ + rax],BYTE r12b
jmp loop_L_
end_loop_L_:

; ustawienie pozycji startowej L:
mov r12b,[KEY]
sub r12b,49

; ustawienie pozycji startowej R:
mov r8b,[KEY+1]
sub r8b,49


read_loop:              ;petla do wczytywanie danych z standartowego wejscia (blokami)

mov rax, 3              ;Wczytuje blok 8 bitow do input
mov rbx, stdin
mov rcx, input
mov rdx, 4096
int 80h

mov r13,rax           ;Zapisuje sobie liczbe wczytanych bitow

cmp rax,1             ;Jezeli nie wczytano zadnego bitu to koncze
jle end_read_loop

xor r10,r10         ;r10 licznik bitow w bloku

loop_block:          ;petla po bloku (szyfrowanie)

lea r15,[input + r10]   ;zaladuj do r15 adres znaku do zaszyfrowania
mov r9b,[r15]           ;zaladuj do r9b w.w. znak

cmp r9b,10
je end_read_loop

cmp r9b,48          ;jezeli znak nie spelnia zalozen tzn nie jest z zakresu ['1','Z'] zakoncz program z kodem bledu
jle error
cmp r9b,91
jge error

turn          ;obrot bebenkow

;SZYFROWANIE:

rot_Q r9b,r8b             ;Qr
rot_R r9b                 ;R
rot_Q_1 r9b,r8b           ;Qr-1
rot_Q r9b,r12b            ;Ql
rot_L r9b                 ;L
rot_Q_1 r9b,r12b          ;Ql-1
rot_T r9b                 ;T
rot_Q r9b,r12b            ;Ql
rot_L_ r9b           ;L-1
rot_Q_1 r9b,r12b          ;Ql-1
rot_Q r9b,r8b             ;Qr
rot_R_ r9b           ;R-1
rot_Q_1 r9b,r8b           ;Qr-1
add r11b,1

mov [output + r10],r9b    ;kopiuje zaszyfrowany znak do output

add r10,1                     ;przechodze do nastepnego znaku

cmp r10,r13               ;sprawdzam czy nie jest to ostatni wczytany znak
jl loop_block            ;jezeli nie jest to ostatni to przechodze do nastepnego znaku

cmp r13,4096
jl end_read_loop       ;jezeli znakow bylo mniej niz 8 to znaczy ze jest to koniec bloku (oraz calego napisu)


;jezeli jest ostatni ale znakow bylo 8 to jest to koniec bloku ale nie koniecznie koniec calego napisu

end_loop_block:      ;jest to juz konec napisu

print output,r13    ;wyswietl zaszyfrowany blok

jmp read_loop
end_read_loop:

print output,r13    ;wyswietl zaszyfrowany blok

exit:
  print newline,1

  mov rax, 60
  xor rdi,rdi
  syscall

error:

print output,r13

  mov rax, 60
  mov rdi, 1
  syscall

_print:        ;rdi -> adres         rsi -> dlugosc
  mov rcx,rdi
  mov rdx,rsi
  mov rax, sys_write
  mov rbx, stdout
  int 80h
ret