#include "idbsp.h"
#include <ctype.h>

typedef struct
{
        char            identification[4];              /* should be IWAD */
				int             numlumps;
				int             infotableofs;
} wadinfo_t;


typedef struct
{
				int             filepos;
        int             size;
        char            name[8];
} lumpinfo_t;


/*
=============================================================================
*/

/*
============
=
= initFromFile:
=
============
*/

/* WADFILE *initFromFile(WADFILE *self,char const *path) */
void initFromFile(void)
{
				wadinfo_t       wad;
				lumpinfo_t      *lumps;
				int                     i;
/*
				self->pathname = malloc(strlen(path)+1);
				strcpy (self->pathname, path);
				self->dirty = false;
				self->handle = open (self->pathname, O_RDWR, 0666);
				if (self->handle== -1)
				{
/*              [self free]; */
/*    return nil; */
/*
								WadfileFree(self);
								return NULL;
				}
*/
/*
 read in the header
*/
/*				read (self->handle, &wad, sizeof(wad)); */
				fread(&wad, sizeof(wad), 1, wad_i.handle);
				if (strncmp(wad.identification,"PWAD",4))
				{
/*
								close (self->handle);
								WadfileFree(self);
								return NULL;
*/
				Error("\ninitFromFile: specified WAD is not a PWAD");
				}
/*
				wad.numlumps = LONG (wad.numlumps);
				wad.infotableofs = LONG (wad.infotableofs);
*/
/*
 read in the lumpinfo
*/
/*				lseek (self->handle, wad.infotableofs, SEEK_SET); */
				fseek(wad_i.handle, wad.infotableofs, SEEK_SET);
/*
				info = [[Storage alloc] initCount: wad.numlumps elementSize: sizeof(lumpinfo_t) description: ""];
				lumps = [info elementAt: 0];
*/
				wad_i.info = (STORAGE *)SafeMalloc(sizeof(STORAGE));
				wad_i.info->data = (lumpinfo_t *)SafeCalloc(wad.numlumps,sizeof(lumpinfo_t));
				wad_i.info->count = wad.numlumps;
				wad_i.info->size = sizeof(lumpinfo_t);
				lumps = wad_i.info->data;

/*				read (self->handle, lumps, wad.numlumps*sizeof(lumpinfo_t)); */
				fread(lumps, sizeof(lumpinfo_t), wad.numlumps, wad_i.handle);
/*
				for (i=0 ; i<wad.numlumps ; i++, lumps++)
				{
								lumps->filepos = LONG (lumps->filepos);
								lumps->size = LONG (lumps->size);
				}
*/
				return;
}


/*
============
=
= initNew:
=
============
*/

void initNew(void)
{
        wadinfo_t       wad;

/*
        self->pathname = malloc(strlen(path)+1);
        strcpy (self->pathname, path);
*/

/*      info = [[Storage alloc] initCount: 0 elementSize: sizeof(lumpinfo_t) description: ""]; */
				wad_i.info = (STORAGE *)SafeMalloc(sizeof(STORAGE));
        wad_i.info->data = (lumpinfo_t *)SafeMalloc(sizeof(lumpinfo_t));
        wad_i.info->size = sizeof(lumpinfo_t);
        wad_i.info->count = 0;

        wad_i.dirty = true;
/*
				self->handle = open (self->pathname, O_CREAT | O_TRUNC | O_RDWR, 0666);
        if (self->handle== -1)
                return NULL;
*/
/* leave space for wad header */
/*      write (self->handle, &wad, sizeof(wad)); */
        fwrite(&wad, sizeof(wad), 1, wad_i.handle);

        return;
}

/* WADFILE *WadfileClose(WADFILE *self) */
void WadfileClose(void)
{
/* close (self->handle); */
        fclose(wad_i.handle);
        return;
}

/* void WadfileFree(WADFILE *self) */
void WadfileFree(void)
{
/*
        close (handle);
        [info free];
        free (self->pathname);
        return [super free];
*/
        fclose(wad_i.handle);
        free(wad_i.info->data);
        free(wad_i.info);
        free(wad_i.pathname);
}

/*
=============================================================================
*/

/* int numLumps(WADFILE *self) */
int numLumps(void)
{
/*      return [info count]; */
        return wad_i.info->count;
}

/* int lumpsize(WADFILE *self,int lump) */
int lumpsize(int lump)
{
        lumpinfo_t      *inf;
/*
        inf = [info elementAt: lump];
				return inf->size;
*/
        inf = wad_i.info->data;
        inf += lump;
        return inf->size;
}

/* int lumpstart(WADFILE *self,int lump) */
int lumpstart(int lump)
{
        lumpinfo_t      *inf;
/*
        inf = [info elementAt: lump];
        return inf->filepos;
*/
        inf = wad_i.info->data;
        inf += lump;
				return inf->filepos;
}

/* char const *lumpname(WADFILE *self,int lump) */
char const *lumpname(int lump)
{
        lumpinfo_t      *inf;
/*
        inf = [info elementAt: lump];
        return inf->name;
*/
        inf = wad_i.info->data;
        inf += lump;
        return inf->name;
}

/*
================
=
= lumpNamed:
=
================
*/

/*int lumpNamed(WADFILE *self,char const *name) */
int lumpNamed(char const *name)
{
        lumpinfo_t      *inf;
        int                     i, count;
        char                    name8[9];
        int                     v1,v2;

/* make the name into two integers for easy compares */

				memset(name8,0,9);
        if (strlen(name) < 9)
                strncpy (name8,name,9);
        for (i=0 ; i<9 ; i++)
                name8[i] = toupper(name8[i]);   /* case insensitive */

        v1 = *(int *)name8;
        v2 = *(int *)&name8[4];


/* scan backwards so patch lump files take precedence */

/*      count = [info count]; */
        count = wad_i.info->count;
        for (i=count-1 ; i>=0 ; i--)
        {
/*              inf = [info elementAt: i]; */
								inf = wad_i.info->data;
                inf += i;
                if ( *(int *)inf->name == v1 && *(int *)&inf->name[4] == v2)
                        return i;
        }
        return  -1;
}

/*
================
=
= loadLump:
=
================
*/

/* void *loadLump(WADFILE *self,int lump) */
void *loadLump(int lump)
{
        lumpinfo_t      *inf;
        byte                    *buf;
/*
        inf = [info elementAt: lump];
        buf = malloc (inf->size);

        lseek (handle, inf->filepos, L_SET);
        read (handle, buf, inf->size);
*/
        inf = wad_i.info->data;
        inf += lump;
        buf = (byte *)malloc(inf->size);
/*
        lseek(self->handle, inf->filepos, SEEK_SET);
        read(self->handle, buf, inf->size);
*/
        fseek(wad_i.handle, inf->filepos, SEEK_SET);
        fread(buf, inf->size, 1, wad_i.handle);

        return buf;
}

/* void *loadLumpNamed(WADFILE *self,char const *name)*/
void *loadLumpNamed(char const *name)
{
/*      return [self loadLump:[self lumpNamed: name]]; */
         return loadLump(lumpNamed(name));
}

/*
============================================================================
*/

/*
================
=
= addName:data:size:
=
================
*/

/* WADFILE *addName(WADFILE *self,char const *name, void *data, int size) */
void addName(char const *name, void *data, int size)
{
        int             i;
        lumpinfo_t      *newlump;

/*
        if (wad_i.info->count > 0)
								{
                wad_i.info->count += 1;
                wad_i.info->data = (lumpinfo_t *)realloc(wad_i.info->data,
                                                                                (wad_i.info->count + 1) * sizeof(lumpinfo_t));
                }
*/

        newlump = (lumpinfo_t *)wad_i.info->data + wad_i.info->count;

        wad_i.dirty = true;
        memset (newlump->name,0,sizeof(newlump->name));
        strncpy (newlump->name, name, 8);
        for (i=0 ; i<8 ; i++)
                newlump->name[i] = toupper(newlump->name[i]);
/*      newlump->filepos = lseek(self->handle,0, L_XTND); */
/*      newlump->filepos = lseek(self->handle,0,SEEK_END); */
        fseek(wad_i.handle, 0, SEEK_END);
				newlump->filepos = ftell(wad_i.handle);
        newlump->size = size;

/*      [info addElement: &new]; */

/*      write (self->handle, data, size); */
        fwrite(data, size, 1, wad_i.handle);

        wad_i.info->count += 1;
        wad_i.info->data = (lumpinfo_t *)realloc(wad_i.info->data,
                                                                                (wad_i.info->count + 1) * sizeof(lumpinfo_t));

        return;
}


/*
================
=
= writeDirectory:
=
        char            identification[4];              // should be IWAD
        int             numlumps;
        int             infotableofs;
================
*/

/* WADFILE *writeDirectory(WADFILE *self) */
void writeDirectory(void)
{
        wadinfo_t       wad;
        int                     i,count;
        lumpinfo_t      *inf;

/*
 write the directory
*/
/*
        count = [info count];
        inf = [info elementAt:0];
*/
        count = wad_i.info->count;
        inf = wad_i.info->data;
/*
        for (i=0 ; i<count ; i++)
        {
                inf[i].filepos = LONG (inf[i].filepos);
                inf[i].size = LONG (inf[i].size);
        }
*/
/*      wad.infotableofs = LONG (lseek(self->handle,0, L_XTND)); */
/*      wad.infotableofs = LONG(lseek(self->handle,0,SEEK_END)); */
        fseek(wad_i.handle,0,SEEK_END);
        wad.infotableofs = ftell(wad_i.handle);

/*      write (self->handle, inf, count*sizeof(lumpinfo_t)); */
        fwrite(inf, sizeof(lumpinfo_t), count, wad_i.handle);
/*
        for (i=0 ; i<count ; i++)
        {
                inf[i].filepos = LONG (inf[i].filepos);
                inf[i].size = LONG (inf[i].size);
        }
*/

/*
 write the header
*/
				strncpy (wad.identification, "PWAD",4);
/*      wad.numlumps = LONG ([info count]); */
        wad.numlumps = wad_i.info->count;
/*
        lseek (self->handle, 0, SEEK_SET);
        write (self->handle, &wad, sizeof(wad));
*/
        fseek(wad_i.handle, 0, SEEK_SET);
        fwrite(&wad, sizeof(wad), 1, wad_i.handle);

        return;
}