#include "pakfile.hpp"
#include "file.hpp"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <assert.h>

int
PakFileSearch(FILE* file, char* filename)
{
   PakEntry    entry;
   PakHeader   ph;

   assert(file && filename);
   
   rewind(file);
   
   if (fread(&ph, sizeof(ph), 1, file) == 1)
   {
      if (!memcmp(ph.magic, "PACK", 4))
      {
         fseek(file, ph.diroffset, SEEK_SET);

         int nentrys = ph.dirsize / sizeof(PakEntry);

         for (int i = 0; i < nentrys; i++)
         {
            fread(&entry, sizeof(PakEntry), 1, file);

            if (!strcmp(filename, entry.filename))
            {
               fseek(file, entry.offset, SEEK_SET);

               return 1;
            }
         }
      }
   }

   return 0;
}

/*
typedef struct paknode_s
{
   struct paknode_s* next;
   pakentry_t        entry;
} paknode_t;

typedef struct
{
   FILE*       file;
   paknode_t*  directory;
} pakfile_t;

pakfile_t*
PakCreate(char* filename)
{
   pakheader_t header;

   pakfile_t* pakfile = calloc(sizeof(pakfile_t), 1);

   if (pakfile)
   {
      pakfile->file = fopen(filename, "wb");

      if (pakfile->file)
      {
         memset(&header, 0, sizeof(pakheader_t));
         fwrite(&header, sizeof(pakheader_t), 1, pakfile->file);

         return pakfile;
      }
      free(pakfile);
   }
   return NULL;
}

void
PakClose(pakfile_t* pack)
{
   pakheader_t header;
   paknode_t*  node;

   memset(&header, 0, sizeof(pakheader_t));
   memcpy(header.magic, "PACK", 4);
   header.diroffset = ftell(pack->file);

   while ((node = pack->directory) != NULL)
   {
      pack->directory = node->next;

      fwrite(&node->entry, sizeof(pakentry_t), 1, pack->file);
      header.dirsize += sizeof(pakentry_t);      
      free(node);
   }

   rewind(pack->file);

   fwrite(&header, sizeof(pakheader_t), 1, pack->file);

   fclose(pack->file);
   
   free(pack);
}

int
PakAdd(pakfile_t* pack, char* filename, const void* ptr, int size)
{
   paknode_t* node = (paknode_t*) calloc(sizeof(paknode_t), 1);

   if (node)
   {
      strcpy(node->entry.filename, filename);
      node->entry.offset = ftell(pack->file);
      node->entry.size   = size;
      node->next         = pack->directory;
      pack->directory    = node;

      fwrite(ptr, size, 1, pack->file);

      return 1;
   }
   return 0;
}
*/