.global _start

.bss
#-Буфер------------------------------------------------------------------------
    .lcomm text, 700000
    .lcomm buffer, 1024
    .lcomm text_in_line, 100000
	.lcomm dec, 11
#------------------------------------------------------------------------------

.text
good_exit:

	movq  $1, %rax
	movq  $1, %rdi
	movq  $countstr, %rsi
	movq  $countstrlen, %rdx
	syscall

	movq  $1, %rax
	movq  $1, %rdi
	movq  $red, %rsi
	movq  $red_len, %rdx
	syscall

	_conv_to_dec:
    pushq $dec+11
    popq %rsi
    movq $0xa, (%rsi)
    movq result_count, %rax
    movq $0xa, %rbx
    mov $1, %rcx
    _next_digit:
      inc %rcx
      xor %rdx, %rdx
      div %rbx
      addq $0x30, %rdx
      dec %rsi
      movb %dl, (%rsi)
      cmp $0, %rax
      jnz _next_digit
    movq %rcx, %rdx
    movq $1, %rax
    movq $1, %rdi
    syscall

	movq  $1, %rax
	movq  $1, %rdi
	movq  $nocolor, %rsi
	movq  $nocolor_len, %rdx
	syscall



    xorq %rbx, %rbx
    movq $60, %rax
    syscall

bad_exit:
    # Выход с 1 кодом ошибки
    movq $1, %rbx
    movq $60, %rax
    syscall
#------------------------------------------------------------------------------

#-Работа с файлом--------------------------------------------------------------
open_file:
    # Открывает файл, указанный в rdi и сохраняет fd в rax
    movq $2, %rax
    xorq %rsi, %rsi
    syscall
    ret

close_file:
    # Закрывает fd, указанный в rdi
    movq $3, %rax
    syscall
    ret

close_file_by_file:
    # Закрывает файл из file
    movq file, %rdi
    call close_file
    ret

open_file_by_file_path:
    # Открывает файл, указанный в file_path и сохраняет fd в file
    movq file_path, %rdi
    call open_file
    movq %rax, file
    ret

read_text_from_file:
    # Читает файл из file в text
    xorq %rax, %rax
    movq file, %rdi
    movq $text, %rsi
    movq $1000000, %rdx
    syscall
    ret
#------------------------------------------------------------------------------

#-Вывод------------------------------------------------------------------------
write:
    # Выводит в поток, указанный в rdi,
    # строку, ссылка на которую в rsi,
    # длины rdx
    movq $1, %rax
    syscall
    ret

stdout:
    # Печатает в stdout строку, ссылка на которую в rsi, длины rdx
    movq $1, %rdi
    call write
    ret

stderr:
    # Печатает в stderr строку, ссылка на которую в rsi, длины rdx
    movq $2, %rdi
    call write
    ret

print_text_in_line:
    # Печатает содержимое text_in_line в stdout
	addq $1, result_count
    call print_register
    xorq %r12, %r12
    print_text_in_line_loop:
        movq $text_in_line, %r14
        addq %r12, %r14
        movq %r14, %rsi
        movq $1, %rdx
        call stdout
            # Если это \n
            cmpb $10, (%r14)
            je ptil
            # Если это конец файла
            cmpb $0, (%r14)
            je ptil
            # Если не конец строки
            cmpq %r14, find_index
            jne ptil_next_0
            movq $red, %rsi
            movq $red_len, %rdx
            call stdout

            ptil_next_0:
            movq find_index, %r13
            addq find_len, %r13
            cmpq %r14, %r13
            jne ptil_next
            movq $nocolor, %rsi
            movq $nocolor_len, %rdx
            call stdout

            ptil_next:
            addq $1, %r12
            jmp print_text_in_line_loop
    ptil:
    ret

print_register:
    # Печатает!
    movq $green, %rsi
    movq $green_len, %rdx
    call stdout
    movq len, %r14
    movq $0, %r13
    pushq $0x20
    pushq $0x3A
    pushq $0x20
    _conv_loop:
        movq %r14, %r15
        and $0x0f, %r15
        cmpq $0x9, %r15
        ja _gt9
        addq $0x30, %r15
        jmp _conv

    _gt9:
        addq $0x37, %r15

    _conv:
        pushq %r15
        addq $1, %r13
        shr $4, %r14
        cmpq $7, %r13
        jne _conv_loop
	movq $0, %r13
    _write_loop:
    addq $1, %r13
    movq $1, %rax
    movq $1, %rdi
    popq buffer
    movq $buffer, %rsi
    movq $1, %rdx
    syscall
    cmpq $10, %r13
    jne _write_loop
    movq $nocolor, %rsi
    movq $nocolor_len, %rdx
    call stdout
    ret
#------------------------------------------------------------------------------

#-Извлечение-------------------------------------------------------------------
get_one_byte:
    # Извлекаем 1 байт из text(итератор) и кладем в строку по адресу r14
    movq $text, %r13
    addq byte_number, %r13
    movb (%r13), %al
    movb %al, (%r14)
    addq $1, byte_number
    addq $1, temp_len
    ret

clear_text_in_line:
    # Очищаем text_in_line от прошлой строки
    xorq %r15, %r15
    for_byte_in_dirty_line:
        movq $text_in_line, %r14
        addq %r15, %r14
        movb $0, (%r14)
        addq $1, %r15
        cmpq $100001, %r15
        jne for_byte_in_dirty_line
        ret

get_one_line:
    # Читает 1 строку из text в text_in_line
    call clear_text_in_line
    xorq %r15, %r15
    for_each_byte_in_line:
        # Смотрим очередной байт
        movq $text_in_line, %r14
        addq %r15, %r14
        call get_one_byte
            # Если это \n
            cmpb $10, (%r14)
            je read_one_byte_finish
            # Если это конец файла
            cmpb $0, (%r14)
            je read_one_byte_end_file
            # Если не конец строки
            addq $1, %r15
            jmp for_each_byte_in_line
    read_one_byte_finish:
        addq $1, row
        ret
    read_one_byte_end_file:
        movb $1, finished_flag
        ret
#------------------------------------------------------------------------------

#-Остальное--------------------------------------------------------------------
get_2_arg:
    xorq %r15, %r15
    for_f_arg:
        movq file_path, %r14
        addq %r15, %r14
        # Если это \n
        cmpb $10, (%r14)
        je get_a
        # Если это 0
        cmpb $0, (%r14)
        je get_a
        # Если еще не все
        addq $1, %r15
        jmp for_f_arg
    get_a:
        addq $1, %r15
        addq file_path, %r15
        movq %r15, find
        call get_find_len
        ret

get_find_len:
    xorq %r15, %r15
    for_fl:
        movq find, %r14
        addq %r15, %r14
        # Если это \n
        cmpb $10, (%r14)
        je get_ll
        # Если это 0
        cmpb $0, (%r14)
        je get_ll
        # Если еще не все
        addq $1, %r15
        jmp for_fl
    get_ll:
        movq %r15, find_len
        ret
_clear:
    movq $clr, %rsi
    movq $clrlen, %rdx
    call stdout
    ret

#------------------------------------------------------------------------------

#-Main-------------------------------------------------------------------------
_start:
    popq %rdi
    popq %rdi
    popq file_path
    call get_2_arg
    call _clear
    call open_file_by_file_path
    call read_text_from_file
    call close_file_by_file

    for_each_line:
        call get_one_line
        call find_string_in_line
        cmpb $1, finded_flag
        jne skip_print
            call print_text_in_line
        skip_print:
            movq temp_len, %r11
            addq %r11, len
            movq $0, temp_len
            # Если кончился файл
            cmpb $1, finished_flag
            je good_exit
        jmp for_each_line
    jmp good_exit
#------------------------------------------------------------------------------

#-Поиск------------------------------------------------------------------------
find_string_in_line:
    xorq %r15, %r15
    xorq %r8, %r8
    for_each_byte_in_line_for_find:
        # Смотрим очередной байт
        movq $text_in_line, %r14
        addq %r15, %r14
        movq find, %r9
        addq %r8, %r9
        movb (%r9), %al
        movb (%r14), %dl
        cmpb %al, %dl
        je next
            # Если это \n
            cmpb $10, (%r14)
            je find_finish
            # Если это конец файла
            cmpb $0, (%r14)
            je find_finish
            # Если не конец строки
            cmpq $0, %r8
            jne xoring
            addq $1, %r15
            xoring:
            xorq %r8, %r8
            jmp for_each_byte_in_line_for_find
    next:
        addq $1, %r8
        addq $1, %r15
        cmpq find_len, %r8
        jne for_each_byte_in_line_for_find
        movb $1, finded_flag
        subq find_len, %r14
        movq %r14, find_index
        ret
    find_finish:
        movb $0, finded_flag
        ret
#------------------------------------------------------------------------------

.data
#-Переменные-------------------------------------------------------------------
file_path: .quad 0
find: .quad 0
find_len: .quad 0
find_index: .quad 0
file: .byte 0
row: .quad 0
len: .quad 0
temp_len: .quad 0
byte_number: .quad 0
finished_flag: .byte 0
finded_flag: .byte 0
clr : .asciz "\033[H\033[2J"
clrlen = . - clr
red: .asciz "\033[101m"
red_len = . - red
green: .asciz "\033[0;32m"
green_len = . - green
nocolor: .asciz "\033[0m\033[K"
nocolor_len = . - nocolor
endfile : .ascii "\n"
endfilelen =  . - endfile
countstr : .ascii "Count : "
countstrlen =  . - countstr
result_count: .int 00
#------------------------------------------------------------------------------