/*
 *  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;

	unsigned char *mem;
	size_t memsize;
	FILE *f;
	long foff;

	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_fopen(FILE *f, const char *name)
{
	unsigned char hdr_buf[LBX_HDR_SIZE];
	struct lbx_state *lbx;

	if (fread(hdr_buf, 1, sizeof hdr_buf, f) != sizeof hdr_buf) {
		lbx_errno = -errno;
		return NULL;
	}

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

	lbx->name = name;
	lbx->f    = f;
	lbx->foff = sizeof hdr_buf;

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

		if (fread(buf, 1, sizeof buf, f) != sizeof buf) {
			lbx_errno = -errno;
			if (feof(f))
				lbx_errno = LBX_EEOF;
			free(lbx);
			return NULL;
		}

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

	return lbx;
}

static int _lbx_memcpy(void *dest, struct lbx_state *src, size_t size)
{
	if (src->foff + size > src->memsize)
		return -1;
	memcpy(dest, src->mem + src->foff, size);
	src->foff += size;
	return 0;
}

struct lbx_state *lbx_mopen(void *_mem, size_t size, const char *name)
{
	struct lbx_state *new = NULL;
	struct lbx_state tmp = { .mem = _mem, .memsize = size };
	uint16_t nfiles, version;
	uint32_t magic;

	if (_lbx_memcpy(&nfiles,  &tmp, sizeof nfiles)  == -1) goto eof;
	if (_lbx_memcpy(&magic,   &tmp, sizeof magic)   == -1) goto eof;
	if (_lbx_memcpy(&version, &tmp, sizeof version) == -1) goto eof;

	nfiles  = letohs(nfiles);
	magic   = letohl(magic);
	version = letohs(version);

	if (magic != LBX_MAGIC) {
		lbx_errno = LBX_EMAGIC;
		return NULL;
	}
	
	new = malloc(sizeof *new + (nfiles+1)*(sizeof *new->offsets));
	if (!new) {
		lbx_errno = -errno;
		return NULL;
	}
	
	*new = (struct lbx_state){
		.name    = name,
		.nfiles  = nfiles,
		.mem     = _mem,
		.memsize = size,
		.foff    = tmp.foff,
	};
	
	if (_lbx_memcpy(new->offsets, new, (nfiles+1)*(sizeof *new->offsets)))
		goto eof;

	return new;
eof:
	free(new);
	lbx_errno = LBX_EEOF;
	return NULL;
}

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_mextract(struct lbx_state *lbx, size_t base, size_t len, FILE *of)
{
	size_t rc;

	assert(lbx->mem);
	assert(base + len <= lbx->memsize);

	rc = fwrite(lbx->mem + base, 1, len, of);
	if (rc < len)
		lbx_errno = -errno;

	return rc;
}

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_fseek(lbx->f, &lbx->foff, base) == -1)
		return 0;
	
	while (len) {
		size_t amt = MIN(len, sizeof buf);

		rc = fread(buf, 1, amt, lbx->f);
		lbx->foff += rc;
		len -= rc;
		if (rc < amt) {
			if (feof(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];

	if (lbx->mem)
		return _lbx_mextract(lbx, base, len, of);
	return _lbx_fextract(lbx, base, len, of);
}

void *lbx_mmap(struct lbx_state *lbx, size_t index, size_t *len)
{
	unsigned char *mapping;
	struct stat statbuf;
	size_t base;

	if (index >= lbx->nfiles) {
		lbx_errno = LBX_ERANGE;
		return NULL;
	}
	
	base = lbx->offsets[index];
	*len = lbx->offsets[index+1] - lbx->offsets[index];

	if (lbx->mem)
		return lbx->mem + base;
	
	if (fstat(fileno(lbx->f), &statbuf) == -1) {
		lbx_errno = -errno;
		return NULL;
	}

	mapping = mmap(NULL, statbuf.st_size, PROT_READ, 0, fileno(lbx->f), 0);
	if (mapping == MAP_FAILED) {
		lbx_errno = -errno;
		return NULL;
	}

	lbx->mem     = mapping;
	lbx->memsize = statbuf.st_size;
	return mapping + base;
}

void lbx_close(struct lbx_state *lbx)
{
	if (!lbx) return;

	if (lbx->f) {
		fclose(lbx->f);
		if (lbx->mem) {
			munmap(lbx->mem, lbx->memsize);
		}
	}

	free(lbx);
}

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";
}