#include <stdio.h>
#include <malloc.h>
#include <string.h>


struct aluno {
     long nusp;
     char nome[50];
     double nota1;
     double nota2;
};


// Declaracoes de prototipos
struct aluno *le_reg();
void remove_reg(void), altera_reg(), exibe_reg(int);
int procura_reg(int), le_opcao();
void msg(char s[]);


// variaveis globais
struct aluno *vet_aluno[50];

int cont_regs = 0; // essa variavel armazena o numero de registros lidos
                    // eh uma variavel global pq diversas funcoes fazem uso


FILE *fp = NULL;   // arquivo


int main()
{
    struct aluno *al;
    int i;

    // le cad aum dos registros e adiciona ao vetor
    for (al = le_reg(), i = 0; al != NULL; al = le_reg(), i++)
    {
        printf("NUSP: %ld\n", al->nusp);
        printf("NOME: %s\n", al->nome);
        printf("NOTA 1: %.1lf\n", al->nota1);
        printf("NOTA 2: %.1lf\n\n\n", al->nota2);
        vet_aluno[i] = al;
    }
    cont_regs = i;
    while ( (i = le_opcao()) != 0 )
    {
        switch (i)
        {
            case 1:
                remove_reg();
                break;
            case 2:
                altera_reg();
                break;
            default:
                msg("Opção invalida");
        }
    }
    for (i = 0; i < cont_regs; i++)
    {
        exibe_reg(i);
        if ( vet_aluno[i] != NULL )
            free(vet_aluno[i]);
    }
    system("pause");
}

/* Essa funcao le um registro do arquivo e devolve um ponteiro para
o registro lido. O registro é alocado dinamicamente.
Caso nao haja mais registros a serem lidos, retorna NULL
Na primeira chamada, abre o arquivo a ser lido. Esse arquivo chama-se
"notats.txt"
*/
struct aluno *le_reg()
{
    long k;
    struct aluno *a1;

    if ( fp == NULL )
    {
        fp = fopen("notas.txt", "r");
        if ( fp != NULL )
           printf("Arquivo aberto com sucesso\n");
    }
    if ( fp == NULL)
    {
        printf("Erro ao ler registro\n");
        return NULL;
    }
    fscanf(fp, "%ld", &k );
    if ( k == 0 ) return NULL;

    a1 = (struct aluno *) malloc(sizeof(struct aluno));
    a1->nusp = k;
    fgets(a1->nome, 49, fp);
    fscanf(fp, "%lf", & (a1->nota1) );
    fscanf(fp, "%lf", & (a1->nota2) );
    return a1;
}

/* Essa funcao retira um registro do vetor. Primeiro faz uma
busca no vetor e depois, se o encontrou, remove o registro do vetor.
Como nao ha novas insercoes, remover significa apenas zerar a posicao
do vetor
*/
void remove_reg(void)
{
    int n, i;

    printf("Digite o NUSP a ser removido da base: ");
    scanf("%d", &n);
    if ( n <= 0 )
    { // verifica se usuario digitou corretamente
        msg("NUSP invalido.");
        return;
    }
    // procura o registro no vetor
    i = procura_reg(n);

    // valor negativo significa que nao encontrou
    if ( i < 0 )
    {
        msg("registro nao encontrado");
        return;
    }
    // remove, colocando NULL no vetor
    vet_aluno[i] = NULL;
    return;
}

/* Essa funcao altera um registro do vetor. Primeiro faz uma
busca no vetor e depois, se o encontrou, le os novos dados pelo teclado
e altera o valor no vetor
*/
void altera_reg(void)
{
    int n, i;
    char s[50];
    double nota;

    printf("Digite o NUSP a ser alterado: ");
    scanf("%d", &n);
    if ( n <= 0 )
    { // verifica se usuario digitou corretamente
        msg("NUSP invalido.");
        return;
    }
    // procura o registro no vetor
    i = procura_reg(n);

    // valor negativo significa que nao encontrou
    if ( i < 0 )
    {
        msg("registro nao encontrado");
        return;
    }
    printf("Digite o nome (enter para manter o valor atual)\n");
    printf("%s\n", vet_aluno[i]->nome);
    gets(s);
    gets(s);
    if ( strlen(s) > 0 )
    {
        strcpy(vet_aluno[i]->nome, s);
    }

    printf("Digite a nota 1 (negativo para manter o valor atual)\n");
    printf("%.1lf\n", vet_aluno[i]->nota1);
    scanf("%lf", &nota );
    if ( nota >= 0.0 )
    {
        vet_aluno[i]->nota1 = nota;
    }

    printf("Digite a nota 1 (negativo para manter o valor atual)\n");
    printf("%.1lf\n", vet_aluno[i]->nota2);
    scanf("%lf", &nota );
    if ( nota >= 0.0 )
    {
        vet_aluno[i]->nota2 = nota;
    }

    return;
}


/* Essa função exibe um dos registros do vetor. Verifica antes de exibir,
se é um NUSP valido (maior que zero)
Parametro: k -- indice do vetor a exibir
*/
void exibe_reg(int k)
{
    if ( vet_aluno[k] != NULL )
    {
        printf("NUSP: %ld\n", vet_aluno[k]->nusp);
        printf("NOME: %s\n", vet_aluno[k]->nome);
        printf("NOTA 1: %.1lf\n", vet_aluno[k]->nota1);
        printf("NOTA 2: %.1lf\n\n\n", vet_aluno[k]->nota2);
    }
    return;
}


/* Essa funcao procura um registro com um determinado numero USP
Parametro: n - numero USP a ser procurado
Retorna: indice do vetor onde esta o registro ou -1 caso não encontre
*/
int procura_reg(int n)
{
    int i;
    for (i = 0; i < cont_regs; i++)
    {
        // se for NULL, posicao esta vazia
        if ( vet_aluno[i] == NULL )
            continue;
        if ( vet_aluno[i]->nusp == n )
            return i;
    }
    return -1;
}



/* exibe um "menu" com as opcoes que o usuario pode escolher
retorna: numero da opcao digitada
*/
int le_opcao()
{
    int k;

    system("cls");
    printf("Escolha uma das opcoes abaixo\n");
    printf("(1) -- Remove registro da base\n");
    printf("(2) -- Altera um registro existente\n");
    printf("(0) -- Termina a execucao do programa\n");
    printf("Digite sua opcao ==> ");
    scanf("%d", &k);
    return k;
}


void msg(char s[])
{
    printf("**************** %s *****************\n", s);
    system("pause");
}