#include <iostream>
#include <fstream>
#include <cstring>

using namespace std;

struct Games {
    char nome[50];
    double anoLancamento;
    char plataforma[40];
    char descricao[250];
};

Games *buscaJogo(fstream *arquivo, char nome[]) // essa função busca um registro pelo nome dele
{
    arquivo->seekg(0);//posiciona o arquivo para o inicio para ler quantos registros existem salvos no arquivo

    int* n = NULL; // inteiro para guarda a quantidade de registros
    n = new int; // alocando um inteiro para armazenar a quantidade de registros do arquivo
    Games *aux = new Games; // registro auxiliar que vai armazenar o registro encontrado ou não

    arquivo->read((char *)n, sizeof(int)); // le do arquivo o inteiro e passa para a variavel n

    for (int i = 0; i < *n; i++) // laço percorrendo todos os registros no arquivo
    {
       arquivo->read((char *)aux, sizeof(Games)); // le um registro do arquivo e passa para a variavel aux

       if (strcmp(aux->nome, nome) == 0) // essa função retorna 0 se as duas cadeias de caracteres forem iguais
       {
           return aux; // retorna o jogo encontrado como resultado
       }
    }

    delete n; // desalocando o ponteiro que guardava a quantidade de registros
    aux->anoLancamento = -1; // caso não tenha encotrado o jogo no arquivo, é atribuido -1 a variavel anoLancamento
                            // para manter um controle e para dizer que não foi possível encontrar o jogo

    return aux; // retorna o registro com dados que não foi encontrado
}

int encontraPosicaoParaInsercaoOrdenada(fstream *arquivo, int anoLancamento, int n) // essa função acha onde deve ser inserido o novo registro
{
    int* posicao = NULL; // variavel que guardara a posição
    posicao = new int; // alocando um ponteiro para armazenar a posição correta de inserção
    *posicao = 0; // atribuindo 0 para a variavel para percorrer de 0 até n

    Games *aux = new Games; // registro auxiliar para encontrar a posição de inserção

    while (*posicao < n) // laço de repetição para encontrar qual posição deve se inserir o novo registro até que a posição seja menor que n
    {
        arquivo->seekg(sizeof(int) + ( sizeof(Games)*(*posicao) )); // posiciona o arquivo de acordo com o valor da posição
        arquivo->read((char *)aux, sizeof(Games)); // le um registro do arquivo e passa para a variavel aux

        if (aux->anoLancamento > anoLancamento) // comparação se o ano de lançamento do registro lido é maior que o novo a ser inserido
        {
            delete aux; // desalocando o ponteiro aux que armazenava os registro do arquivo

            return *posicao; // retorna o inteiro que armazena qual posição devera ser inserido
            //break; // inutil ainda...
        }
        (*posicao)++; // incrementa a posição para controlar onde sera inserido
    }

    delete aux; // desalocando o ponteiro aux que armazenava os registro do arquivo

    return *posicao; // retorno a ultima posição do arquivo já que o novo ano do registro não é menor que nenhum dado do arquivo'
}

void imprimeJogos(fstream *arquivo) // função que imprime todos os dados do arquivos
{
    Games *aux = new Games; // registro auxiliar para controlar a impressão dos dados
    arquivo->seekg(0); //posiciona o arquivo para o inicio para ler quantos registros existem salvos no arquivo
    int *n = NULL; // inteiro para guardar a quantidade de registros, atribuindo NULL como forma de segurança
    n = new int; // alocando um inteiro para n

    arquivo->read((char *)n, sizeof(int)); // le do arquivo o inteiro e passa para a variavel n

    cout << "===========================================================================" << endl;
    cout << "=================     Existem " << *n << " Jogos Cadastrados      ====================" << endl << endl;

    for (int i = 0; i < *n; i++) // laço de repetição percorrendo todos os registros do arquivo
    {
        arquivo->read((char *)aux, sizeof(Games)); // le um registro do arquivo e passa para a variavel aux
        cout << "===========================================================================" << endl;
        cout << "==== Nome = " << aux->nome << endl;
        cout << "==== Ano de Lançamento = " << aux->anoLancamento << endl;
        cout << "==== Plataforma do Jogo = " << aux->plataforma << endl;
        cout << "==== Descrição do Jogo = " << aux->descricao << endl;
        cout << "===========================================================================" << endl;
        // OBS.: não preciso posicionar mais o arquivo, pois em C++, quando se lê algo do arquivo,
        // o arquivo pula para próxima posição disponivel, sendo assim não precisa posicionar ele de novo
    }

    delete n; // desalocando o ponteiro que guardava a quantidade de registros
    delete aux; // desalocando o ponteiro aux que armazenava os registro do arquivo

    cout << endl;
}

void insereNoArquivo(Games *novoJogo, fstream *arquivo, int posicao, int &n) // essa função insere o novo registro já ordenado no arquivo
{
    arquivo->seekp(0); //posiciona o arquivo para o inicio para ler quantos registros existem salvos no arquivo
    n++; // incrementa o n antecipadamente para atualizar a quantidade de registro no arquivo

    arquivo->write((char *)&n, sizeof(int)); // escreve o valor da variavel n no arquivo, escreve em cima da variavel n que ja estava antes no arquivo
    n--; // decrementa n para ter controle de quantos registros já estavam cadastrados no arquivo

    Games *aux = new Games; // registro auxiliar para manipular os regitros já inscrito no arquivo

    for (int i = n-1; i >= posicao; i--) // laço de repetição començando do tamanho menos um ate a posição que deve ser inserido o novo registro
    {
        arquivo->seekg(sizeof(int) + sizeof(Games)*i); // posiciona o arquivo com a determinada posição que deve ser lida
        arquivo->read((char *)aux, sizeof(Games)); // le o registro posicionado e passa para o registro aux

        arquivo->seekp(sizeof(int) + sizeof(Games)*(i+1)); // posiciona o arquivo para próxima posição que tinha sido posicionado antes
        arquivo->write((char *)aux, sizeof(Games)); // escreve o registro auxiliar lido anteriormente e escreve ele no arquivo como sucessor do que foi lido

        // essas quatros linhas faz com que troque todos os registros de posição, porem ele troca todos, passando eles para frente, pois quando for adicionar
        // o novo registro no arquivo, vai adicionar ele em uma posição "vazia", já que trocou todos de lugar
        // desenhando e explicando pessoalmente é melhor

        arquivo->flush(); // essa funçao meio que atualiza o arquivo
    }

    arquivo->seekp(sizeof(int) + sizeof(Games)*posicao); // posiciona o arquivo na posição que deve ser inserida
    arquivo->write((char *)novoJogo, sizeof(Games)); // insere o novo registro no arquivo, com a posição correta
    arquivo->flush(); // essa funçao meio que atualiza o arquivo

    n++; // atualiza o valor de n para utilizar futuramente

    delete aux; // desalocando o ponteiro aux que armazenava os registro do arquivo
}

bool atualizaJogo(fstream *arquivo, char nome[])
{
    arquivo->seekg(0); //posiciona o arquivo para o inicio para ler quantos registros existem salvos no arquivo

    int *n = NULL; // inteiro para guardar a quantidade de registros, atribuindo NULL como forma de segurança
    n = new int; // alocando um inteiro para n

    bool* ok = NULL; // bool para guardar o estado da quantidade
    ok = new bool; // alocando um boleano para ok
    *ok = false; // atribuindo false como forma de manter controle da operação

    arquivo->read((char *)n, sizeof(int)); // le do arquivo o inteiro e passa para a variavel n

    Games *aux = new Games; // registro auxiliar para manipular dados salvos

    for (int i = 0; i < *n && *ok == false; i++) // laço percorrendo todos os registros no arquivo
    {
        arquivo->read((char *)aux, sizeof(Games)); // le um registro do arquivo e passa para a variavel aux

        if (strcmp(aux->nome, nome) == 0) // essa função retorna 0 se as duas cadeias de caracteres forem iguais
        {
            cout << "===========================================================================" << endl;
            cout << "========== Atualize os dados do jogo -> " << aux->nome << endl;

            cout << "========== Nome Do Jogo -> ";
            cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
            cin.get(aux->nome, 50); // essa função pega a linha inteira digitada pelo console

            cout << "========== Ano de Lançamento do Jogo -> ";
            cin >> aux->anoLancamento;

            cout << "========== Plataforma do Jogo -> ";
            cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
            cin.get(aux->plataforma, 40); // essa função pega a linha inteira digitada pelo console

            cout << "========== Descrição do Jogo -> ";
            cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
            cin.get(aux->descricao, 250); // essa função pega a linha inteira digitada pelo console

            arquivo->seekp(sizeof(int) + sizeof(Games)*i); // posiciona o arquivo na posição que deve ser inserida
            arquivo->write((char *)aux, sizeof(Games)); // insere o novo registro no arquivo, com a posição correta
            arquivo->flush(); // essa funçao meio que atualiza o arquivo depois de uma alteração

            *ok = true; // atribuindo true como forma de informar que foi possível alterar o dado
            cout << "===========================================================================" << endl << endl;
       }
    }

    delete n; // desalocando o ponteiro que guardava a quantidade de registros
    delete aux; // desalocando o ponteiro aux que armazenava os registro do arquivo

    if (*ok == true) // conferindo se foi possível editar o dado
    {
        return true;
    }
    else // caso não foi possível entrará aqui
    {
        return false;
    }
}

int main()
{
    int* n = NULL; // inteiro para guarda a quantidade de registros
    n = new int; // alocando um inteiro para armazenar a quantidade de registros do arquivo
    *n = 0; // atribui 0 para escrever no arquivo, caso não exista um arquivo

    fstream arquivo("Games.bin", ios::binary| ios::in | ios::out ); // abre o arquivo já "existente" para leitura e escrita

    if (arquivo.good() == false) // confere se o arquivo está ilegivel
    {
         arquivo.open("Games.bin", ios::binary|  ios::in | ios::out |ios::trunc); // caso o arquivo não esteja legivel, é aberto um novo arquivo, com o mesmo
                                                                                  // nome, porem descartando tudo que existe no arquivo
         arquivo.write((char *) n,sizeof(int)); // escreve no arquivo o valor de n
    }
    else
    {
        arquivo.read((char*)n, sizeof(int)); // le do arquivo o valor de n e escreve em n
    }

    int* posicao = NULL; // // variaveis que aramazenara a posição correta de inserção
    posicao = new int; // aloca um inteiro para guardar a posição de inserção

    int* operacao = NULL; // variaveis que ira ajudar no controle das operações do arquivo
    operacao = new int; // aloca um inteiro para manipular a operação desejada

    do
    {
        if (arquivo.good() == false) // caso o arquivo esteja com algum problema durante a manipulção
        {
            cout << "=========================== Erro no Arquivo ===============================" << endl;
        }

        cout << "===========================================================================" << endl;
        cout << "========== Digite uma das opções para realizar uma operação     ===========" << endl;
        cout << "========== 1 - Para Inserir novo Jogo no arquivo                ===========" << endl;
        cout << "========== 2 - Para Atualizar um Jogo no arquivo                ===========" << endl;
        cout << "========== 3 - Para Buscar um Jogo no arquivo                   ===========" << endl;
        cout << "========== 4 - Para Listar todos os Jogos do arquivo            ===========" << endl;
        cout << "========== 0 - Para Sair                                        ===========" << endl;
        cout << "===========================================================================" << endl;
        cout << "========== ";

        cin >> *operacao;

        cout << endl;

        switch (*operacao)
        {
            case 1:
            {
                Games *jogo = new Games; // variavel que servira para adicionar um novo registro no arquivo

                cout << "===========================================================================" << endl;
                cout << "==========             Digite os campos necessários              ==========" << endl;
                cout << "===========================================================================" << endl;

                cout << "========== Nome Do Jogo -> ";

                cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
                cin.get(jogo->nome, 50); // essa função pega a linha inteira digitada pelo console

                cout << "========== Ano de Lançamento do Jogo -> ";
                cin >> jogo->anoLancamento;

                cout << "========== Plataforma do Jogo -> ";

                cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
                cin.get(jogo->plataforma, 40); // essa função pega a linha inteira digitada pelo console

                cout << "========== Descrição do Jogo -> ";

                cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
                cin.get(jogo->descricao, 250); // essa função pega a linha inteira digitada pelo console

                *posicao = encontraPosicaoParaInsercaoOrdenada(&arquivo, jogo->anoLancamento, *n); // armazenara o valor da posição de inserção do novo dado
                insereNoArquivo(jogo, &arquivo, *posicao, *n); // chama a função e insere o novo registro

                cout << "===========================================================================" << endl;
                cout << "====================     Jogo Cadastrado Com Sucesso!     =================" << endl;
                cout << "===========================================================================" << endl << endl;

                delete posicao; // desalocando o inteiro que armazenava a posição de inserção
                delete[] jogo; // desalocando o registro que foi ultilizado para inserir no arquivo

                break;
            }
            case 2:
            {
                char* nomeJogoEditar = new char[50]; // alocando um vetor de char para guardar o nome do jogo que vai ser editado

                cout << "===========================================================================" << endl;
                cout << "========== Digite o nome do Jogo a ser Atualizado no Arquivo    ===========" << endl;
                cout << "===========================================================================" << endl;

                cout << "========== ";

                cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
                cin.get(nomeJogoEditar, 50); // essa função pega a linha inteira digitada pelo console

                cout << "===========================================================================" << endl << endl;

                bool* ok = NULL; // bool para guardar o estado da quantidade
                ok = new bool; // alocando um boleano para ok
                *ok = false; // atribuindo false como forma de manter controle da operação

                *ok = atualizaJogo(&arquivo, nomeJogoEditar); // armazenando o valor retornado pela função

                if (*ok == true)
                {
                    cout << "===========================================================================" << endl;
                    cout << "====================  Dados atualizados com sucesso!  =====================" << endl;
                    cout << "===========================================================================" << endl << endl;
                }
                else
                {
                    cout << "===========================================================================" << endl;
                    cout << "=== Não foi possível atualizar os dados desse jogo, tente novamente...  ===" << endl;
                    cout << "===========================================================================" << endl << endl;
                }

                delete ok; // deletando o ponteiro que guardava o estado da operação
                delete[] nomeJogoEditar; // deletando o vetor de char que guardava o nome do jogo a ser editado

                break;
            }
            case 3:
            {
                Games *jogoEncontrado = NULL; // ponteiro que guarda o registro que vai ser procurado
                char* nomeJogo = new char[50]; // alocando um vetor de char para guardar o nome do jogo a ser pesquisado

                cout << "===========================================================================" << endl;
                cout << "========== Digite o nome do Jogo a ser Buscado no Arquivo       ===========" << endl;
                cout << "===========================================================================" << endl;
                cout << "========== ";

                cin.ignore(); // essa função "ignora" caracteres que já estão no console, serve como forma de limpar o teclado
                cin.get(nomeJogo, 50); // essa função pega a linha inteira digitada pelo console

                cout << "===========================================================================" << endl << endl;

                jogoEncontrado = buscaJogo(&arquivo, nomeJogo); // armazenara o valor que foi encontrado pela função

                if (jogoEncontrado->anoLancamento == -1) // um controle, caso não tenha encontrado o jogo no arquivo
                {
                    cout << "===========================================================================" << endl;
                    cout << "========== Nenhum jogo com esse nome foi encontrado...          ===========" << endl;
                    cout << "===========================================================================" << endl << endl;
                } else {
                    cout << "===========================================================================" << endl;
                    cout << "======================      Jogo encontrado       =========================" << endl;
                    cout << "===========================================================================" << endl;
                    cout << "==== Nome = " << jogoEncontrado->nome << endl;
                    cout << "==== Ano de Lançamento = " << jogoEncontrado->anoLancamento << endl;
                    cout << "==== Plataforma do Jogo = " << jogoEncontrado->plataforma << endl;
                    cout << "==== Descrição do Jogo = " << jogoEncontrado->descricao << endl;
                    cout << "===========================================================================" << endl << endl;
                }

                delete[] nomeJogo; // desalocando o vetor de char que armazenava o nome do jogo
                delete[] jogoEncontrado; // desalocando o registro que armazenou o resultado da busca

                break;
            }
            case 4:
            {
                imprimeJogos(&arquivo); // imprimindo todos os jogos do arquivo
                break;
            }

        }

    } while (*operacao != 0);

    cout << "===========================================================================" << endl;
    cout << "==========================       Até Logo...      =========================" << endl;
    cout << "===========================================================================" << endl;

    delete n; // desalocando o inteiro que armazenava a quantidade de registros no arquivo
    delete operacao; // desalocando o inteiro que manipulava as operações

    arquivo.close(); // fecha o arquivo de maneira segura

    return 0;
}