/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/hogmaker/hog.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:56 $
 * $Author: kevinb $
 *
 *
 *
 * $Log: not supported by cvs2svn $
 *
 * 2     3/31/98 6:13p Samir
 * new hogfile format.
 *
 * 1     3/31/98 5:15p Samir
 * new hog file read and write module.
 *
 * $NoKeywords: $
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <sys/stat.h>

#include "hogfile.h"
#include "pstypes.h"
#include "macros.h"

/*	HOG FILE FORMAT v2.0

                HOG_TAG_STR			[strlen()]
                NFILES				[int32]
                HDRINFO				[HOG_HDR_SIZE]
                FILE_TABLE			[sizeof(FILE_ENTRY) * NFILES]
                FILE 0				[filelen(FILE 0)]
                FILE 1				[filelen(FILE 1)]
                .
                .
                .
                FILE NFILES-1		[filelen(NFILES -1)]
*/

////////////////////////////////////////////////////////////////////////

bool CopyFile(FILE *ofp, FILE *ifp, int length) {
#define BUFFER_SIZE (1024 * 1024) //	1 meg

  char *buffer;

  buffer = (char *)malloc(BUFFER_SIZE);
  if (!buffer)
    return false;

  while (length) {
    size_t n, read_len;

    read_len = min(length, (int)BUFFER_SIZE);

    n = fread(buffer, 1, read_len, ifp);
    if (n != read_len) {
      free(buffer);
      return false;
    }

    if (fwrite(buffer, 1, read_len, ofp) != read_len) {
      free(buffer);
      return false;
    }

    length -= read_len;
  }

  free(buffer);

  return true;
}

bool ReadHogHeader(FILE *fp, tHogHeader *header) {
  int res = 0;
  res = fread(&header->nfiles, sizeof(header->nfiles), 1, fp);
  res = fwrite(&header->file_data_offset, sizeof(header->file_data_offset), 1, fp);

  if (res)
    return true;
  else
    return false;
}

bool ReadHogEntry(FILE *fp, tHogFileEntry *entry) {
  int res = 0;
  res = fread(entry->name, strlen(entry->name), 1, fp);
  res = fread(&entry->flags, sizeof(entry->flags), 1, fp);
  res = fread(&entry->len, sizeof(entry->len), 1, fp);
  res = fread(&entry->timestamp, sizeof(entry->timestamp), 1, fp);

  if (res)
    return true;
  else
    return false;
}

inline bool WRITE_FILE_ENTRY(FILE *fp, tHogFileEntry *entry) {
  int res = 0;
  res = fwrite(entry->name, strlen(entry->name), 1, fp);
  res = fwrite(&entry->flags, sizeof(entry->flags), 1, fp);
  res = fwrite(&entry->len, sizeof(entry->len), 1, fp);
  res = fwrite(&entry->timestamp, sizeof(entry->timestamp), 1, fp);

  if (res)
    return true;
  else
    return false;
}

////////////////////////////////////////////////////////////////////////
//	create new hog file

#define HOGMAKER_ERROR 0
#define HOGMAKER_OK 1
#define HOGMAKER_MEMORY 2
#define HOGMAKER_OUTFILE 3
#define HOGMAKER_INFILE 4
#define HOGMAKER_COPY 5

int NewHogFile(const char *hogname, int nfiles, const char **filenames) {
  unsigned i;
  int table_pos;
  FILE *hog_fp;
  tHogHeader header;
  tHogFileEntry *table;
  char ext[_MAX_EXT];

  //	allocate file table
  if (nfiles <= 0)
    return HOGMAKER_ERROR;

  table = new tHogFileEntry[nfiles];
  if (!table)
    return HOGMAKER_MEMORY;

  //	create new file
  hog_fp = fopen(hogname, "wb");
  if (hog_fp == NULL) {
    delete[] table;
    return HOGMAKER_OUTFILE;
  }

  // write the tag
  if (!fwrite(HOG_TAG_STR, strlen(HOG_TAG_STR), 1, hog_fp)) {
    delete[] table;
    fclose(hog_fp);
    return HOGMAKER_OUTFILE;
  }

  // write number of files
  uint8_t filler = 0xff;
  header.nfiles = (unsigned)nfiles;
  header.file_data_offset = strlen(HOG_TAG_STR) + HOG_HDR_SIZE + (sizeof(tHogFileEntry) * header.nfiles);

  if (!fwrite(&header.nfiles, sizeof(header.nfiles), 1, hog_fp)) {
    delete[] table;
    fclose(hog_fp);
    return HOGMAKER_OUTFILE;
  }
  if (!fwrite(&header.file_data_offset, sizeof(header.file_data_offset), 1, hog_fp)) {
    delete[] table;
    fclose(hog_fp);
    return HOGMAKER_OUTFILE;
  }
  if (!fwrite(&filler, sizeof(uint8_t), HOG_HDR_SIZE - sizeof(tHogHeader), hog_fp)) {
    delete[] table;
    fclose(hog_fp);
    return HOGMAKER_OUTFILE;
  }

  // save file position of index table and write out dummy table
  table_pos = strlen(HOG_TAG_STR) + HOG_HDR_SIZE;

  memset(&table[0], 0, sizeof(table[0]));

  for (i = 0; i < header.nfiles; i++) {
    if (!WRITE_FILE_ENTRY(hog_fp, &table[0])) {
      delete[] table;
      fclose(hog_fp);
      return HOGMAKER_OUTFILE;
    }
  }

  // write files (& build index)
  for (i = 0; i < header.nfiles; i++) {
    FILE *ifp;
    struct _stat mystat;

    ifp = fopen(filenames[i], "rb");
    if (ifp == NULL) {
      delete[] table;
      fclose(hog_fp);
      return HOGMAKER_INFILE;
    }

    _splitpath(filenames[i], NULL, NULL, table[i].name, ext);
    _fstat(fileno(ifp), &mystat);

    strcat(table[i].name, ext);
    table[i].flags = 0;
    table[i].len = _filelength(_fileno(ifp));
    table[i].timestamp = mystat.st_mtime;

    if (!CopyFile(hog_fp, ifp, table[i].len)) {
      delete[] table;
      fclose(hog_fp);
      return HOGMAKER_COPY;
    }

    fclose(ifp);
  }

  // now write the real index
  fseek(hog_fp, table_pos, SEEK_SET);

  for (i = 0; i < header.nfiles; i++) {
    if (!WRITE_FILE_ENTRY(hog_fp, &table[i])) {
      delete[] table;
      fclose(hog_fp);
      return HOGMAKER_OUTFILE;
    }
  }

  //	cleanup
  fclose(hog_fp);
  delete[] table;

  return HOGMAKER_OK;
}

/*	CopyFile
                used to copy one file to another.
*/