#include "stdafx.h"
#include "Data.h"
#include "stdlib.h"
#include "time.h"
#include "string.h"

MY_CAR *CreateArray(size_t no_items)
{
    MY_CAR *tab = (MY_CAR *)malloc(no_items * sizeof(MY_CAR));
    if (tab)
        memset(tab, 0, no_items * sizeof(MY_CAR));
    return tab;
}

MY_CAR * FreeArray(MY_CAR *tab)
{
    if (tab)
    {
        size_t it, no_items = _msize(tab) / sizeof(MY_CAR);
        for (it = 0; it < no_items; ++it)
        {
            if (tab[it].model)
                free(tab[it].model);
            tab[it].model = NULL;
        }

        free(tab);
        tab = NULL;
    }

    return NULL;
}

int FillArray(MY_CAR *tab)
{
    char ch = 'a';
    char str[128];
    size_t it, no_items = _msize(tab) / sizeof(MY_CAR);
    int s_begin = 32, s_end = 127, symb, len, i, year = 1000;

    srand(time(NULL));

    for (it = 0; it < no_items; ++it)
    {
        len = rand()*20/RAND_MAX+5;

        for (i = 0; i < len; ++i)
        {
            //symb = 'a'; //rand() * (127 - 32) / RAND_MAX + 32;
            str[i] = ch;
            ch++;
        }
        str[i] = '\0';

        tab[it].model = (char *)malloc((len + 1) * sizeof(char));
        if (!tab[it].model)
            return 0;

        strcpy_s(tab[it].model, (len + 1) * sizeof(char), str);
        tab[it].year = year++;
    }

    return 1;
}

void PrintArray(MY_CAR *tab, char *title)
{
    printf("%s\n", title);
    size_t it, no_items = _msize(tab) / sizeof(MY_CAR);

    for (it = 0; it < no_items; ++it)
    {
        printf("%s   %d\n", tab[it].model, tab[it].year);
    }
}

void MyExit(FILE *pft, MY_CAR *tab, __int64 *fdesc)
{
    if (pft)
        fclose(pft);

    FreeArray(tab);

    if (fdesc)
        free(fdesc);

    printf("fatal error\n");
    system("pause");
    exit(1);
}

void Save(MY_CAR * tab, char *filename)
{
    size_t it, no_items = _msize(tab) / sizeof(MY_CAR);
    unsigned int no_it = (unsigned int)no_items;
    __int64 filepos = 0;
    __int64 *file_desc = (__int64 *)malloc((no_items + 1) * sizeof(__int64));
    if(!file_desc)
        MyExit(NULL, tab, file_desc);

    FILE *pf = fopen(filename, "wb");
    if (!pf)
        MyExit(pf, tab, file_desc);

    if (fwrite(&no_it, sizeof(unsigned int), 1, pf) != 1)
        MyExit(pf, tab, file_desc);


    //rezerwujemy miejsce w pliku dla file_descr
    _fseeki64(pf, (no_items + 1) * sizeof(__int64), SEEK_CUR);

    for (it = 0; it < no_items; ++it)
    {
        file_desc[it] = ftell(pf);
        tab[it].len = (unsigned int)(strlen(tab[it].model) + 1);

        if (fwrite(&tab[it], sizeof(tab[0]), 1, pf) != 1) //sizeof(MY_CAR)
            MyExit(pf, tab, file_desc);

        if (fwrite(tab[it].model, sizeof(tab[it].model[0]), (size_t)(tab[it].len), pf) != (size_t)(tab[it].len))
            MyExit(pf, tab, file_desc);
    }

    file_desc[it] = ftell(pf);   //!!!

    //zapisujemy wskazniki pozycji dla kazdego recordu
    _fseeki64(pf, sizeof(unsigned int), SEEK_SET);
    if (fwrite(file_desc, sizeof(__int64), no_items + 1, pf) != no_items + 1)
        MyExit(pf, tab, file_desc);

    if(pf)
        fclose(pf);
    pf = NULL;

    if (file_desc)
        free(file_desc);
    file_desc = NULL;
}

MY_CAR * Read(MY_CAR * tab, char *filename)
{
    if (tab)
        tab = FreeArray(tab);

    unsigned int no_items = 0, it, rec;
    __int64 rec_len;
    __int64 *file_desc = NULL;

    FILE *pf = fopen(filename, "rb");
    if(!pf)
        MyExit(pf, tab, file_desc);

    if(fread(&no_items, sizeof(unsigned int), 1, pf) != 1)
        MyExit(pf, tab, file_desc);

    tab = CreateArray((size_t)no_items);
    file_desc = (__int64 *)malloc((no_items + 1) * sizeof(__int64));
    if(!tab || !file_desc)
        MyExit(pf, tab, file_desc);

    if(fread(file_desc, sizeof(file_desc[0]), no_items + 1, pf) != no_items + 1)
        MyExit(pf, tab, file_desc);

    for (it = 0; it < no_items; ++it)
    {
        rec = no_items - it - 1;
        rec_len = file_desc[rec + 1] - file_desc[rec];

        _fseeki64(pf, file_desc[rec], SEEK_SET);
        if(fread(&tab[rec], sizeof(tab[rec]), 1, pf) != 1)
            MyExit(pf, tab, file_desc);

        tab[rec].model = (char *)malloc(tab[rec].len*sizeof(char));
        if(!tab[rec].model)
            MyExit(pf, tab, file_desc);

        if(fread(tab[rec].model, sizeof(char), tab[rec].len, pf) != tab[rec].len)
            MyExit(pf, tab, file_desc);
    }

    if (file_desc)
        free(file_desc);
    file_desc = NULL;

    if (pf)
        fclose(pf);
    pf = NULL;

    return tab;
}


// data.h


#pragma once

#pragma warning (disable : 4996)

struct MY_CAR
{
    int year;
    char *model;

    //Dla systemu zapisu - odczytu
    unsigned int len;  //ilosc slow w tablice model
};

MY_CAR * CreateArray(size_t no_items);
MY_CAR * FreeArray(MY_CAR * tab);
int FillArray(MY_CAR *tab);
void PrintArray(MY_CAR *tab, char *title);
void MyExit(FILE *pft, MY_CAR *tab, __int64 *fdesc);

void Save(MY_CAR * tab, char *filename);
MY_CAR * Read(MY_CAR * tab, char *filename);