; Reset the disk system using int 13h / AH = 00h
disk_reset:
   pusha
   stc
   mov ah, 00h
   int 13h
   popa
   ret

; ------------------------------------

; Load the root directory into memory (into disk_buffer which is 24000h)
disk_load_root:
   pusha
   mov ax, 19 ; First sector of root entry
   call math_lba_to_chs ; Assigns ch, cl and dh the correct values
   xor ax,ax ; clear ax so I can use it on next line
   mov dl, [ebr_drive_number]  ; Drive number
   mov ah, 02h  ; BIOS ah code for read disk sectors to memory
   mov al, 0Ch  ; Root directory has 12 sectors

   mov si, root_buffer		; ES:BX should point to our buffer
   mov bx, si

   ; repeat drive read 3 times (incase of random error)
   mov di, 3 ; counter
   ; This is basically
   ; for di in range(3,1,1):
   ; We test to see if we can read the disk 3 times
.try_read_disk: ; Try read the floppy three times
   ; When the disk is tried to be read, the CF flag will be
   ; set if there's an error, so we just clear it to return it to
   ; the default state
   stc ; sets the cf flag
   int 13h
   jnc .done_read ; jump if cf = 0

   call disk_reset ; Reset drivers of disk

   dec di       ; di -= 1
   test di, di   ; if di = 0
   jnz .try_read_disk
   jmp .disk_error
.disk_error:
   mov si, disk_read_fail
   call os_print_string
   popa
   ret
.done_read:
   popa
   ret

; ---------------------------------------------

; Reads a certain number of sectors into memory
; IN
; ax = LBA
; es:bx = area to read to/write from
; [read_write_flag] = 02 or 03 for read or write
; dl = ebr drive number
; int 13h/ah = 02h/03h read/write disk sectors into memory
; al = number of sectors to read
; ah = read/write 02=read, 03=write IMPORTANT
; ch = cylinder number
; cl = sector number
; dh = head number
; dl = drive number
; es:bx = points to data buffer
disk_read_or_write:
   push ax
   push bx
   push cx
   push dx
   push di

   ; cl = sector
   ; ch = cylinder
   ; dh = head
   ; dl = drive
   call math_lba_to_chs  ; Get the chs address

   mov ah, [read_write_flag]
   mov al, 1

   ; repeat drive read 3 times (incase of random error)
   mov di, 3 ; counter

; This is basically
; for di in range(3,1,1):
; We test to see if we can read the disk 3 times
.retry:
   ; When the disk is tried to be read, the CF flag will be
   ; set if there's an error, so we just clear it to return it to
   ; the default state
   stc ; sets the cf flag
   int 13h
   jnc .done_read ; jump if cf = 0

   call .disk_reset ; Reset drivers of disk

   dec di       ; di -= 1
   test di, di   ; if di = 0
   jnz .retry

.fail_disk_read:
   pop di
   pop dx
   pop cx
   pop bx
   pop ax
   ret

; int 13h / ah = 00h reset disk system
.disk_reset:
   pusha
   mov ah, 0 ; Reset drive
   stc
   int 13h
   jc .fail_disk_read
   popa
   ret

.done_read:
   pop di
   pop dx
   pop cx
   pop bx
   pop ax
   ret


; -------------------------------------
; CLEAR DATA
; Uses the metadata buffer to determine the file size in the data buffer and clears it.
disk_clear_file_buffer:
	pusha

	mov si, metadata_buffer
	mov cx, [si+28] ; MOve the filelength into the ax
	shr cx, 1 ; Divide by 4 because we'll write over using double words
	mov si, empty_word
	lodsb ; Load the empty dword
	mov di, file_buffer
	.loop:
		stosb
		dec cx
		cmp cx, 0
		jbe .loop
	.finish:
		popa
		ret
disk_clear_output_buffer:
	pusha
	mov cx, 0x7f0 ; Length of the output buffer
	mov si, empty_word
	lodsb ; Load the empty word into ax
	mov di, output_buffer
	.loop:
		stosb ; Store empty dword in di
		dec cx
		cmp cx, 0
		ja .loop
	.finish:
		popa
		ret

; -------------------------------------
; IN
; si: filename

; OUT
; data_buffer: file contents
; TODO use predefined data for calculations
disk_load_file:
   pusha
   call os_string_length ; cl = string length
   cmp cl, 11
   ja .filename_too_long

   mov di, fat12_file_name
   call os_format_fat_filename

   ; Prepare values
   mov si, root_buffer
   xor bx,bx
.search_root:
   mov di, fat12_file_name ; Move the name of the kernel into di
   mov cx, 11 ; length of filenames in fat12
   push si ; Preserve si
   repe cmpsb ; Repeat a comparison of bytes between file name and current bytes until it finds a match
   pop si ; Retrieve si
   je .found_file

   add si, 32 ; increment di to the next directory entry
   inc bx
   cmp bx, [bdb_dir_entries_count] ; Have we reached the number of directories that exist
   jl .search_root ; Repeat search

   jmp .file_not_found ; If the last dir has been searched, then there is no kernel
.found_file:
   call disk_clear_file_buffer
   mov di, metadata_buffer
   mov cx, 32
.write_metadata:
   ; Write data to metadata buffer
   lodsb
   stosb
   sub cx, 1
   cmp cx, 0
   jne .write_metadata
.read_kernel:
   sub si, 32
   mov ax, [si+28]   ; File length
   mov [file_length], ax
   mov ax, [si+26]   ; ax is now a pointer to the pointer to the file relative to the data segments :D
   add ax, 1Fh
   mov [file_cluster], ax
   ; Setup registers for disk read
   mov si, file_buffer
   mov bx, si
   mov dl, [ebr_drive_number]

   mov ch, 02h
   mov [read_write_flag], ch ; READ
   call disk_read_or_write ; Load file from disk into memory
   jmp .done
.file_not_found:
   mov si, file_not_found
   call os_print_string
   jmp .done
.filename_too_long:
   mov si, too_long_filename
   call os_print_string
   jmp .done
.done:
   popa
   ret

; Write data to file
; takes the contents in the data buffer for a fixed
; number of characters definied by [file_length]
; and write it to the file that si points to
; It also must edit the fat entry data
disk_write_file:
	pusha
	; Check if file name is too long
	call os_string_length ; cl = string length
	cmp cl, 11
	ja .filename_too_long
	; Convert file name to a fat filename
	mov di, fat12_file_name
	call os_format_fat_filename

	; Locate the file entry in memory
	; Prepare values
	mov si, root_buffer
	xor bx,bx
	.search_root:
		mov di, fat12_file_name ; Move the name of the kernel into di
		mov cx, 11 ; length of filenames in fat12
		push si ; Preserve si
		repe cmpsb ; Repeat a comparison of bytes between file name and current bytes until it finds a match
		pop si ; Retrieve si
		je .found_file

		add si, 32 ; increment di to the next directory entry
		inc bx
		cmp bx, [bdb_dir_entries_count] ; Have we reached the number of directories that exist
		jl .search_root ; Repeat search

		jmp .file_not_found ; If the last dir has been searched, then there is no kernel
	.found_file:
	; Find where the file is on the disk
		mov ax, [si+28]   ; File length entry
		mov [file_length], ax
		mov ax, [si+26]   ; ax is now a pointer to the pointer to the file relative to the data segments :D
		add ax, 1Fh
		mov [file_cluster], ax
		; Setup registers for disk read
		mov si, file_buffer
		mov bx, si
		mov dl, [ebr_drive_number]

		mov ch, 03h
		mov [read_write_flag], ch ; WRITE
		call disk_read_or_write ; Load file from disk into memory
		jmp .finish
	; DI now points to a fat12 formatted file name

	; Write to those sectors
	; Update FAT entry
	.file_not_found: ; TODO create a file if it's not found
		mov si, file_not_found
		call os_print_string
		jmp .finish
	.filename_too_long:
		mov si, too_long_filename
		call os_print_string
		jmp .finish
	.finish:
		popa
		ret

; TODO support long file names
; Store a list of the files in file_buffer
; in a human readable format
; OUT
; output_buffer: the list (string)
disk_list_contents:
	pusha
	mov si, root_buffer
	mov di, output_buffer
	.loop:
		call string_unformat_fat_filename
		mov cx, 000Ch
		sub cx, [file_name_length]
		add di, [file_name_length]
		mov al, 20h
		.space_loop:
			stosb
			dec cx
			cmp cx, 0
			jne .space_loop

		.file_attribute:
			add si, 11d
			lodsb
			push si

			mov si, read_only
			cmp al, 1h
			je .add_string
			mov si, hidden
			cmp al, 2h
			je .add_string
			mov si, system
			cmp al, 4h
			je .add_string
			mov si, volume
			cmp al, 8h
			je .add_string
			mov si, directory
			cmp al, 10h
			je .add_string
			mov si, archive
			cmp al, 20h
			je .add_string

		.after_file_attributes:
		pop si

		mov al, 0Ah
		stosb

		add si, 20d
		lodsb ; +1
		dec si ; -1
		cmp al, 0 ; You've come to the end of the root entries
		je .finish
		cmp al, 00E5h	; E5h is a marker that the Fat entry is available
		je .finish
		jmp .loop
	.add_string:
		.add_string_loop:
			lodsb
			cmp ax, 00h
			je .after_file_attributes
			stosb
			jmp .add_string_loop
	.finish:
		mov cx, output_buffer
		sub di, cx
		mov [file_length], di
		stosb
		popa
		ret