/*
 *  2ooM: The Master of Orion II Reverse Engineering Project
 *  Library for working with LBX archive files.
 *  Copyright (C) 2006-2008 Nick Bowler
 *
 *  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/>.
 */
#ifdef HAVE_CONFIG_H
#	include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <assert.h>

#include <sys/stat.h>
#include <sys/mman.h>

#include "pack.h"
#include "misc.h"
#include "lbx.h"

#define LBX_MAGIC    0x0000fead
#define LBX_HDR_SIZE 8

int lbx_errno = 0;

struct lbx_state {
	const char *name;

	const struct lbx_file_ops *fops;
	int (*dtor)(void *handle);
	void *f;

	uint16_t nfiles;
	uint32_t offsets[];
};

static struct lbx_state *lbx_init(unsigned char hdr[static LBX_HDR_SIZE])
{
	unsigned short nfiles  = unpack_16_le(hdr+0);
	unsigned long  magic   = unpack_32_le(hdr+2);
	unsigned short version = unpack_16_le(hdr+6);
	struct lbx_state *lbx;

	if (magic != LBX_MAGIC) {
		lbx_errno = -LBX_EMAGIC;
		return NULL;
	}

	lbx = malloc(sizeof *lbx + sizeof lbx->offsets[0] * (nfiles+1));
	if (!lbx) {
		lbx_errno = -errno;
		return NULL;
	}

	*lbx = (struct lbx_state) {
		.nfiles = nfiles,
	};

	return lbx;
}

struct lbx_state *lbx_open(void *f, const struct lbx_file_ops *fops,
                           int (*destructor)(void *), const char *name)
{
	unsigned char hdr_buf[LBX_HDR_SIZE];
	struct lbx_state *lbx;

	if (fops->read(hdr_buf, sizeof hdr_buf, f) != sizeof hdr_buf) {
		lbx_errno = -errno;
		return NULL;
	}

	lbx = lbx_init(hdr_buf);
	if (!lbx)
		return NULL;

	lbx->dtor = destructor;
	lbx->name = name;
	lbx->fops = fops;
	lbx->f    = f;

	for (unsigned i = 0; i <= lbx->nfiles; i++) {
		unsigned char buf[4];

		if (fops->read(buf, sizeof buf, f) != sizeof buf) {
			lbx_errno = -errno;
			if (fops->eof(f))
				lbx_errno = LBX_EEOF;
			free(lbx);
			return NULL;
		}

		lbx->offsets[i] = unpack_32_le(buf);
	}

	return lbx;
}

struct lbx_state *lbx_fopen(FILE *f, const char *name)
{
	return lbx_open(f, &lbx_default_fops, NULL, name);
}

size_t lbx_numfiles(struct lbx_state *lbx)
{
	return lbx->nfiles;
}

int lbx_stat(struct lbx_state *lbx, size_t index, struct lbx_statbuf *buf)
{
	static char str[256]; /* FIXME */

	if (index >= lbx->nfiles) {
		buf->name = NULL;
		lbx_errno = LBX_ERANGE;
		return -1;
	}

	snprintf(str, sizeof str, "%s.%03zu", lbx->name, index);
	buf->name = str;
	buf->size = lbx->offsets[index+1] - lbx->offsets[index];
	return 0;
}

static size_t
_lbx_fextract(struct lbx_state *lbx, size_t base, size_t len, FILE *of)
{
	unsigned char buf[1024];
	size_t rc, written = 0;

	assert(lbx->f);

	if (lbx->fops->seek(lbx->f, base, SEEK_SET) != 0) {
		lbx_errno = -errno;
		return 0;
	}
	
	while (len) {
		size_t amt = MIN(len, sizeof buf);

		rc = lbx->fops->read(buf, amt, lbx->f);
		len -= rc;
		if (rc < amt) {
			if (lbx->fops->eof(lbx->f)) lbx_errno = LBX_EEOF;
			else lbx_errno = -errno;
			break;
		}

		rc = fwrite(buf, 1, amt, of);
		written += rc;
		if (rc < amt) {
			lbx_errno = -errno;
			break;
		}
	}

	return written;
}

size_t lbx_extract(struct lbx_state *lbx, size_t index, FILE *of)
{
	size_t base, len;

	if (index >= lbx->nfiles) {
		lbx_errno = LBX_ERANGE;
		return 0;
	}
	
	base = lbx->offsets[index];
	len  = lbx->offsets[index+1] - lbx->offsets[index];
	return _lbx_fextract(lbx, base, len, of);
}

int lbx_close(struct lbx_state *lbx)
{
	int rc = 0;

	if (lbx && lbx->dtor)
		rc = lbx->dtor(lbx->f);
	free(lbx);

	return rc;
}

const char *lbx_strerror(void)
{
	if (lbx_errno < 0)
		return strerror(-lbx_errno);

	switch (lbx_errno) {
	case LBX_ESUCCESS: return "Success";
	case LBX_EMAGIC:   return "Bad magic number";
	case LBX_EEOF:     return "Unexpected end-of-file";
	case LBX_ERANGE:   return "Index out of range";
	case LBX_EFORMAT:  return "Invalid file format";
	}

	return "Unknown error";
}