########################## TRABALHO FINAL ##########################
            ################### SIMULADOR DE SISTEMA BANCÁRIO ##################
            ### DUPLA: PAULO ROBERTO NUNES DA ROSA / DOMARYS DA SILVA CORREA ###

.data
    String0: .asciiz "\nInforme o tipo de usuário(1.Cliente|2.Funcionário|3.Administrador|4.Fechar Terminal):"
    String1: .asciiz "###ERRO###\nOpção Informada não existe!!!"
    String2: .asciiz "Você deseja fazer um:\n1.Deposito\n2.Saque\n3.Transferência\nOpção desejada:"
    String3: .asciiz "Você deseja fazer um:\n1.Cadastro de Clientes\n2.Cadastro de Funcionário\nOpção desejada:"
    String4: .asciiz "\nInforme o Nome:"
    String5: .asciiz "\nCPF:"
    String6: .asciiz "\nSenha:"
    String7: .asciiz "\nSaldo Inicial:"
    String8: .asciiz "\nDeseja realizar outra operação(1.Sim|2.Não)?"
    String9: .asciiz "\nInforme a Senha:"
    String10:.asciiz "Senha informada é incorreta!\n"
    String11:.asciiz "Você deseja fazer um:\n1.Cadastro de Clientes\n2.Cadastro de Funcionário\nOpção desejada:"
    String12:.asciiz "\nInforme o número da conta:"
    String13:.asciiz "\nInforme o número do funcionário:"
    String14:.asciiz "\nDADOS INCORRETOS!!!\n"
    String15:.asciiz "\nQuanto deseja depositar?"
    String16:.asciiz "\nSeu saldo anterior era:R$"
    String17:.asciiz "\nSeu saldo atual é:R$"
    String18:.asciiz "\nQuanto deseja Sacar?"
    String19:.asciiz "\nA quantidade que você deseja transferir é:"
    String20:.asciiz "\nNúmero da conta para transferir:"
    String21:.asciiz "\nO Saldo anterior da conta do beneficiário era:R$"
    String22:.asciiz "\nO Saldo atual da conta do beneficiário é:R$"
    String23:.asciiz "\nNão tem nenhum cadastro de Cliente!!!"
    String24:.asciiz "\nNão tem nenhum cadastro de Funcionário!!!"
.text

                    ### PROGRAMA PRINCIPAL ###

    MAIN:       lui $a3,0x1001
            addi $a3,$a3,0x0500
            move $s6,$a3        #Coloca o endereço 0x10010500 em $s6, o espaço de memória apartir desse endereço será usado para o cadastro de Funcionários, o espaço acaba quando chegar no espaço correspondente de clientes
            lui $a2,0x1001
            addi $a2,$a2,0x0600
            move $s5,$a2        #Coloca o endereço 0x10010600 em $s5, o espaço de memória apartir desse endereço será usado para cadastro de clientes

    INICIO:     jal LOGIN       #Chama a Função LOGIN
            nop
            move $t0,$v0        #o valor que retorna da função (que determina a opção escolhida) é salvo em $t0

    IFMENU:     bne $t0,1,ELSEMENU  #Verifica se a opção selecionada foi a de modo cliente se não for ele segue para ELSEMENU
            nop
            beq $s3,0,ERROCLIENTE
            nop
            move $a0,$t0        #manda o valor da seleção do menu para $a0
            jal SENHA       #chama a função SENHA
            nop

    MENU1:      jal MENUCLIENT      #chama a função MENUCLIENT
            nop
            move $a1,$v0        #o valor que retornou do menu na opção escolhida é salvo em $a1 para ser enviado para a função como parâmetro
            jal FUNCAOCLIENT    #chama a função FUNCAOCLIENT
            nop
            la $a0,String8      #printa a string que pergunta se tem alguma outra função que se deseja realizar
            li $v0,4
            syscall
            li $v0,5        #lê a opção informada
            syscall
            beq $v0,1,MENU1     #se deseja realizar outra opção volta para MENU1
            nop
            j INICIO        #se não deseja realizar outra função volta para o inicio
            nop

    ELSEMENU:   bne $t0,2,ADMIN     #verifica se a opção selecionada no meno LOGIN foi 2 que é FUNCIONÁRIO
            nop
            beq $s4,0,ERROFUNC
            nop
            move $a0,$t0        #manda o valor da seleção do menu para $a0
            jal SENHA       #chama a função SENHA
            nop

    MENU2:      jal MENUFUNC        #chama a função MENUFUNC
            nop

    JUMPADMIN:  move $a1,$v0        #o valor que retornou do menu na opção escolhida é salvo em $a1 para ser enviado para a função como parâmetro
            jal FUNCAOFUNCIO    #chama a funçao FUNCAOFUNCIO que e responsavel pelas operaçoes dos funcionarios
            nop
            move $a2,$v0        #salva o endereço da memória onde foi feito o último cadastro de cliente, indicando onde pode começar o próximo cadastro
            move $a3,$v1        #salva o endereço de memória onde foi feito o último cadastro de funcionário, indicando onde pode começar o proximo cadastro
            la $a0,String8      #printa a string que pergunta se o usuário deseja realizar outra operação
            li $v0,4
            syscall
            li $v0,5        #lê a opção escolhida
            syscall
            beq $v0,1,MENU2     #se deseja realizar outra operação vai para MENU2
            nop
            j INICIO        #se não deseja realizar outra operação volta para o INICIO
            nop

    ADMIN:      bne $t0,3,FIM       #se opção informada não for 3 para admin vai para ERROR
            nop

    DENOVO:     la $a0,String9      #se for admin printa a string que pede para informar a senha
            li $v0,4
            syscall
            li $v0,5        #lê a senha
            syscall
            bne $v0,1111,ERROSENHAA #testa para ver se a senha é do admin(que no caso é 1111), se não for vai para ERROSENHAA
            nop
            la $a0,String11     #se senha estiver correta printa a string que pergunta qual cadastro se deseja fazer, cliente ou funcionário
            li $v0,4
            syscall
            li $v0,5        #lê a opção informada pelo usuário
            syscall
            bne $v0,1,TESTE1    #se for cadastro não for para cliente, vai para TESTE1
            nop
            j JUMPADMIN     #se cadastro for de cliente vai para JUMPADMIN

    TESTE1:     bne $v0,2,ERROR     #se opção informada foi errada vai para ERROR
            nop
            j JUMPADMIN     #se é para fazer cadastro de funcionário vai para JUMPADMIN
            nop

    ERROR:      la $a0,String1      #printa a string que informa que a opção escolhida não existe
            li $v0,4
            syscall
            j INICIO        #volta para o inicio do programa
            nop

    ERROCLIENTE:    la $a0, String23    #coloca na tela a String0
            li $v0,4
            syscall
            j INICIO
            nop
    ERROFUNC:   la $a0, String24    #coloca na tela a String0
            li $v0,4
            syscall
            j INICIO
            nop

    ERROSENHAA: la $a0,String10     #printa string que informa que foi colocada errada a senha do administrador
            li $v0,4
            syscall
            j DENOVO        #vai para DENOVO ler novamente a senha do administrador
            nop

    FIM:        bne $t0,4,ERROR     #testa se a opção escolhida é igual a quatro, se sim encerra o programa, se não vai para ERROR
            nop
            li $v0,10       #encerra o programa
            syscall

    ### Essa Função determina se o acesso ao sistema e feito como cliente, funcionário ou administrador ###
LOGIN:      la $a0, String0     #coloca na tela a String0
        li $v0,4
        syscall
        li $v0,5        #lê o inteiro correspondente a opção do menu de LOGIN
        syscall
        jr $ra
        nop

            ### Essa funçao realiza as opçoes do modo cliente ###

FUNCAOCLIENT:   move $t7,$s7            #salva o endereço de memória que corresponde ao cliente que está usando em $t7

DEPOSITO:
        bne $a1,1,SAQUE         #testa se a opção selecionada do menu foi depósito, se não for vai para saque
        nop
        addi $t7,$t7,36         #pula para a parte da memória que corresponde ao saldo do cliente
        lw $t3,0($t7)           #coloca o saldo do cliente em $t3
        la $a0,String15         #Chama a String que pergunta o quanto o cliente deseja depositar
        li $v0,4
        syscall
        li $v0,5            #lê a quantidade do depósito
        syscall
        move $t4,$v0            #salva a quantidade do depósito em $t4
        la $a0,String16         #chama a string para informar o saldo anterior
        li $v0,4
        syscall
        move $a0,$t3            #printa o saldo anterior
        li $v0,1
        syscall
        add $t3,$t4,$t3         #Soma o valor novo na conta do cliente
        la $a0,String17         #mostra a string que determina o valor atual do saldo do cliente
        li $v0,4
        syscall
        move $a0,$t3            #passa o saldo atual para $a0
        li $v0,1            #printa o saldo atual
        syscall
        sw $t3,0($t7)           #salva o saldo atual na memória
        j RETORNAF          #retorna para o programa principal
        nop

SAQUE:      bne $a1,2,TRANSF        #testa se a opção selecionada do menu foi para saque, se não for vai para transferência
        nop
        addi $t7,$t7,36         #pula para a parte da memória que corresponde ao saldo do cliente
        lw $t3,0($t7)           #carrega o saldo do cliente
        la $a0,String18         #printa  a string que pergunta o quanto o cliente quer sacar
        li $v0,4
        syscall
        li $v0,5            #lê a quantidade que o cliente quer sacar
        syscall
        move $t4,$v0            #coloca o valor do saque em $t4
        la $a0,String16         #printa a string que vai mostrar o saldo anterior
        li $v0,4
        syscall
        move $a0,$t3            #salva o saldo anterior em $a0
        li $v0,1            #printa o saldo anterior
        syscall
        sub $t3,$t3,$t4         #diminui o valor do saque do saldo atual
        la $a0,String17         #printa a string que vai mostrar o saldo atual
        li $v0,4
        syscall
        move $a0,$t3            #salva o saldo atual em $a0
        li $v0,1            #printa o saldo atual após o saque
        syscall
        sw $t3,0($t7)           #salva o valor do saldo atual na memória
        j RETORNAF
        nop

TRANSF:     bne $a1,3,ERROR2        #verifica se o valor lido do menu é diferente das opções corretas, se for vai para ERROR2
        nop
        la $a0,String19         #printa a string que pergunta a quantidade que o cliente deseja transferir
        li $v0,4
        syscall
        li $v0,5            #lê o valor da transferência
        syscall
        move $t4,$v0            #salva o valor da transferência em $t4
        addi $t7,$t7,36         #pula para a parte da memória que corresponde ao saldo do cliente
        lw $t3,0($t7)           #carrega o saldo do cliente
        sub $t2,$t3,$t4         #subtrai o valor da transferência do saldo do cliente
        sw $t2,0($t7)           #salva na memória o saldo atualizado do cliente


VOLTATRANSF:    la $a0,String20         #printa a string que pede o número da conta para transferir
        li $v0,4
        syscall
        li $v0,5            #lê o número da conta para transferir
        syscall
        move $t5,$v0            #salva o número da conta em $t5
        move $t6,$s5            #salva o primeiro endereço de memória que corresponde aos clientes em $t6

BUSCATRANSF:    lw $t1,0($t6)           #carrega o primeiro endereço que corresponde ao espaço de memória reservado para número de conta de clientes
        bne $t1,$t5,PROXIMATRANSF   #Verifica se o numero da conta do cliente corresponde com o informado se não vai para PROXIMATRANSF
        nop
        addi $t6,$t6,36         #vai para o campo que corresponde ao saldo que se deseja realizar a transferÊncia
        lw $t1,0($t6)           #carrega o valor do saldo em $t1
        la $a0,String16         #printa a string que mostra o saldo anterior do cliente
        li $v0,4
        syscall
        move $a0,$t3            #coloca o saldo anterior do cliente em $a0
        li $v0,1            #printa o saldo anterior do cliente
        syscall
        la $a0,String21         #printa a string que mostra o saldo anterior do beneficiário
        li $v0,4
        syscall
        move $a0,$t1            #printa o saldo anterior do beneficiário
        li $v0,1
        syscall
        la $a0,String17         #printa a string que mostra o saldo atual do cliente
        li $v0,4
        syscall
        move $a0,$t2            #coloca o saldo atual em $a0
        li $v0,1            #printa o saldo atual
        syscall
        add $t1,$t1,$t4         #soma o valor da transferência ao saldo atual do beneficiário
        sw $t1,0($t6)           #coloca na memória o saldo atualizado do beneficiário
        la $a0,String22         #printa a string que mostra o saldo atual do beneficiário
        li $v0,4
        syscall
        move $a0,$t1            #salva o saldo atual do beneficiário em $a0
        li $v0,1            #printa o saldo do beneficiário atualizado
        syscall
        j RETORNAF          #vai para RETORNAF
        nop

PROXIMATRANSF:  beq $t1,$zero,CONTAINVTRANSF    #testa para ver se o número de conta informada e nulo se for vai para CONTAINVTRANSF
        nop
        addi $t6,$t6,40         #vai para a próxima conta que está na memória
        j BUSCATRANSF           #vai para BUSCATRANSF
        nop

CONTAINVTRANSF: la $a0,String14         #printa a string informando que os dados informados sao invalidos
        li $v0,4
        syscall
        j VOLTATRANSF           #vai para VOLTATRANSF ler o dado da conta para transferência novamente
        nop

ERROR2:     la $a0, String1         #printa a string que informa que o valor de opção do menu que foi informado é incorreto
        li $v0,4
        syscall

RETORNAF:   jr $ra              #volta para o programa principal
        nop

    ### Essa funçao mostra as opçoes do menu para cliente, ela le a opçao escolhida e retorna o valor lido ###

MENUCLIENT: la $a0, String2         #printa a string que mostra as opçoes que o cliente tem
        li $v0,4
        syscall
        li $v0,5            #lê a opção selecionada
        syscall
        jr $ra              #retorna para o programa principal
        nop

### Essa função verifica se o modo selecionado corresponde a cliente ou funcionário, e lê a senha e o número de conta ou número do funcionário e busca na memória para ver se existem os valores informados ###

SENHA:      move $s7,$a0            #passa o valor da opção lida no menu para $s7
        bne $s7,1,SENHAFUNC     #se a opçao escolhida for funcionario ele vai para SENHAFUNC
        nop

VOLTA:      move $t5,$s5            #pega o primeiro endereço da área de memória reservada para clientes e coloca em $t5
        move $s7,$t5            #coloca uma copia do endereço em $s7 para ser usado na função cliente
        la $a0, String9         #printa a string que pede para informar a senha
        li $v0,4
        syscall
        li $v0,5            #lê a senha
        syscall
        move $t1,$v0            #coloca a senha lida em $t1
        la $a0, String12        #printa a string que pede para informar o numero de conta do cliente
        li $v0,4
        syscall
        li $v0,5            #lê o número da conta
        syscall
        move $t2,$v0            #salva o número da conta em $t2

BUSCACLIENTE:   move $t7,$t5            #salva o endereço que está em $t5 no registrador $t7
        lw $t3,0($t7)           #carrega o dado da memória que corresponde ao número da conta
        bne $t3,$t2,PROXIMA     #verifica se o número da conta lida é o mesmo desse endereço, se não for vai para a próxima conta na memória
        nop
        addi $t7,$t7,32         #se o número de conta estiver corredo, é somado no endereço 32 bytes para ele pular para o campo que corresponde a senha
        lw $t3,0($t7)           #carrega a senha e salva em $t3
        beq $t3,$t1,RETORNA     #verifica se a senha informada é a correta, se for vai para RETORNA
        nop
        j CONTAINV          #se senha informada estiver incorreta vai para  CONTAINV
        nop

PROXIMA:    beq $t3,$zero,CONTAINV      #verifica se o número de conta é válido, se não for vai para CONTAINV
        nop
        addi $t5,$t5,40         #se a valor é válido vai para a próxima conta para ver se encontra o número de conta correto
        j BUSCACLIENTE          #volta para BUSCACLIENTE
        nop

CONTAINV:   la $a0,String14         #printa a String que avisa que os dados informados estao errados
        li $v0,4
        syscall
        j VOLTA             #vai para VOLTA que pede os dados novamente
        nop

SENHAFUNC:  move $t6,$s6            #pega o primeiro endereço da área de memória reservada para funcionários e coloca em $t6
        la $a0, String9         #prnta string que pede senha
        li $v0,4
        syscall
        li $v0,5            #lê a senha
        syscall
        move $t1,$v0            #salva a senha em $t1
        la $a0, String13        #printa a string que pede o número do funcionário
        li $v0,4
        syscall
        li $v0,5            #lê o número do funcionário
        syscall
        move $t2,$v0            #salva o número do funcionário em $t2
BUSCAFUNC:  move $t7,$t6            #coloca o endereço de $t6 em $t7
        lw $t3,0($t7)           #carrega o campo número de funcionário da memória
        bne $t3,$t2,PROXIMA2        #se o número informado não existe nessa posição de memória ele vai para PROXIMA2
        nop
        addi $t7,$t7,32         #se número existe, é somado 32bytes em $t7 para ir para o campo da senha do funcionário
        lw $t3,0($t7)           #carrega a senha do funcionário em $t3
        beq $t3,$t1,RETORNA     #testa para ver se a senha lida está correta, se estiver vai para RETORNA
        nop
        j CONTAINV2         #se senha for incorreta vai para CONTAINV2
        nop
PROXIMA2:   beq $t3,$zero,CONTAINV2     #vê se número de funcionário é válido, se não for vai para CONTAINV2
        nop
        addi $t6,$t6,36         #número sendo válido vai para o próximo número até encontrar o correto, ou se caso não existir encontrar um inválido e ler tudo novamente
        j BUSCAFUNC         #vai para BUSCAFUNC
        nop
CONTAINV2:  la $a0,String14         #printa a string informando que os dados estão incorretos
        li $v0,4
        syscall
        j SENHAFUNC         #vai para SENHAFUNC ler os dados novamente
        nop
RETORNA:    jr $ra              #volta para o programa principal
        nop

        ### Essa função mostra as opções de menu do funcionário, e lê a opção que o cliente escolheu ###

MENUFUNC:   la $a0, String3         #printa a string que mostra as opçoes do funcionario
        li $v0,4
        syscall
        li $v0,5            #lê a opção escolhida
        syscall
        jr $ra              #volta para o programa principal
        nop

    ### Essa função realiza as operações possíveis para funcionários, que é cadastro de funcionário e de cliente ###

FUNCAOFUNCIO:   bne $a1,1,CADASTROFUNC      #Primeiro Cadastro é para Clientes se for 1
        nop
        addi $s3,$s3,1
        addi $s1,$s1,1          #Contador para número de contas de clientes
        sw $s1,0($a2)           #coloca na primeira posição da memória correspondente ao cadastro do cliente o número da conta
        addi $a2,$a2,4          #soma 4 no endereço e vai para a próxima posição que corresponde ao armazenamento do nome do cliente
        #Informe o Nome:
        la $a0, String4         #printa a string que pede para informar o nome
        li $v0,4
        syscall
        move $a0,$a2            #salva o endereço onde será armazenado o nome em $a0
        li $a1,15           #número máximo de char por nome é 15
        li $v0,8            #lê string de nome do cliente
        syscall
        addi $a2,$a2,16         #soma no endereço 16 para ir para o próximo campo de memória que é do cpf
        #CPF:
        la $a0, String5 #CPF        #printa a string que pede para informar o CPF
        li $v0,4
        syscall
        move $a0,$a2            #coloca endereço onde a string do cpf sera salva
        li $a1,12           #determina o tamanho da string
        li $v0,8            #le string do cpf
        syscall
        addi $a2,$a2,12         #vai para a proxima posiçao de memoria correspondente a senha
        #Senha:
        la $a0, String6         #printa a string que pede para informar a senha
        li $v0,4
        syscall
        li $v0,5            #le a senha
        syscall
        sw $v0,0($a2)           #coloca a senha no seu endereço de memoria
        addi $a2,$a2,4          #vai para a proxima posiçao de memoria que corresponde ao saldo inicial
        #Saldo Inicial:
        la $a0, String7         #printa a string que pede para informar o saldo inicial do cliente
        li $v0,4
        syscall
        li $v0,5            #le o saldo inicial do cliente
        syscall
        sw $v0,0($a2)           #salva o saldo na memoria
        addi $a2,$a2,4          #vai para a proxima posiçao de memoria que podera ter um cadastro
        move $v0,$a2            #salva o endereoço em $v0 para retornar para o programa principal
        move $v1,$a3
        j RETURN            #retorna para o programa principal
        nop

CADASTROFUNC:   bne $a1,2,ERROR1        #verifica se [e para fazer cadastro de funcionário, se não vai para ERROR1
        nop
        addi $s4,$s4,1
        addi $s3,$s3,1          #Contador para número de funcionários
        sw $s3,0($a3)           #coloca na memória o número do funcionário
        addi $a3,$a3,4          #vai para a próxima posição que corresponde ao nome
        #Informe o Nome:
        la $a0, String4         #printa a string que pede para informar o nome do funcionário
        li $v0,4
        syscall
        move $a0,$a3            #coloca em $a0 o endereço onde será salvo o nome
        li $a1,15           #determina o número máximo de char do nome
        li $v0,8            #lê nome
        syscall
        addi $a3,$a3,16         #vai para próxima posição da memória que é do cpf
        #CPF:
        la $a0, String5         #printa string que pede o cpf
        li $v0,4
        syscall
        move $a0,$a3            #salva endereço que é para colocar o cpf em $a0
        li $a1,12           #determina o número máximo de char do cpf
        li $v0,8            #lê cpf
        syscall
        addi $a3,$a3,12         #vai para a próxima posição de memória que corresponde a senha do funcionário
        #Senha:
        la $a0, String6         #printa string que pede para informar senha
        li $v0,4
        syscall
        li $v0,5            #lê senha
        syscall
        sw $v0,0($a3)           #salva senha na memória
        addi $a3,$a3,4          #vai para a próxima posição disponível para cadastro
        move $v1,$a3            #salva endereço de próximo funcionário em $v1
        move $v0,$a2            #salva endereço de próximo cliente em $v0
        j RETURN            #vai para RETURN
        nop

ERROR1:     la $a0, String1         #printa string informando que opção escolhida não existe
        li $v0,4
        syscall

RETURN:     jr $ra              #volta para o programa principal
        nop