/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant 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 2 of the License, or
   (at your option) any later version.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "wal.h"

#include "ifilesystem.h"

#include "os/path.h"
#include "stream/stringstream.h"
#include "bytestreamutils.h"
#include "imagelib.h"

const int QUAKE2_WAL   = 0;
const int HERETIC2_M8  = 1;

typedef unsigned char byte;

struct pcx_header_t
{
	char manufacturer;
	char version;
	char encoding;
	char bits_per_pixel;
};

void LoadPCXPalette( const char *filename, byte palette[768] ){
	byte* buffer;
	int length = vfsLoadFile( filename, (void **)&buffer );
	if ( buffer == 0 ) {
		return;
	}

	const pcx_header_t* pcx = reinterpret_cast<const pcx_header_t*>( buffer );

	if ( pcx->manufacturer != 0x0a
		 || pcx->version != 5
		 || pcx->encoding != 1
		 || pcx->bits_per_pixel != 8 ) {
		return;
	}

	memcpy( palette, buffer + length - 768, 768 );

	vfsFreeFile( buffer );
}

const int WAL_NAME_LENGTH = 32;
const int WAL_MIPMAP_COUNT = 4;
struct wal_header_t
{
	char name[WAL_NAME_LENGTH];
	unsigned width, height;
	unsigned offsets[WAL_MIPMAP_COUNT];       // four mip maps stored
	char animname[WAL_NAME_LENGTH];         // next frame in animation chain
	int flags;
	int contents;
	int value;
};

const int M8_NAME_LENGTH = 32;
const int M8_MIPMAP_COUNT = 16;
struct m8_header_t
{
	int version;
	char name[M8_NAME_LENGTH];
	unsigned width[M8_MIPMAP_COUNT], height[M8_MIPMAP_COUNT];   // width and height of each mipmap
	unsigned offsets[M8_MIPMAP_COUNT];             // 16 mip maps stored
	char animname[M8_NAME_LENGTH];                // next frame in animation chain
	byte palette[768];                // palette stored in m8
	int flags;
	int contents;
	int value;
};

Image* LoadMipTex( byte* buffer, byte TypeofTex ){
	int w, h, offset, flags, contents, value;
	byte palette[768];
	byte* source;

	PointerInputStream inputStream( buffer );

	if ( TypeofTex == HERETIC2_M8 ) {
		inputStream.seek( 4 + M8_NAME_LENGTH ); // version, name
		w = istream_read_int32_le( inputStream );
		inputStream.seek( 4 * ( M8_MIPMAP_COUNT - 1 ) ); // remaining widths
		h = istream_read_int32_le( inputStream );
		inputStream.seek( 4 * ( M8_MIPMAP_COUNT - 1 ) ); // remaining heights
		offset = istream_read_int32_le( inputStream );
		inputStream.seek( 4 * ( M8_MIPMAP_COUNT - 1 ) ); // remaining offsets
		inputStream.seek( M8_NAME_LENGTH ); // animname
		inputStream.read( palette, 768 );
		flags = istream_read_int32_le( inputStream );
		contents = istream_read_int32_le( inputStream );
		value = istream_read_int32_le( inputStream );
		source = buffer + offset;
	}
	else
	{
		LoadPCXPalette( "pics/colormap.pcx", palette );

		inputStream.seek( WAL_NAME_LENGTH ); // name
		w = istream_read_int32_le( inputStream );
		h = istream_read_int32_le( inputStream );
		offset = istream_read_int32_le( inputStream );
		inputStream.seek( 4 * ( WAL_MIPMAP_COUNT - 1 ) ); // remaining offsets
		inputStream.seek( WAL_NAME_LENGTH ); // animname
		flags = istream_read_int32_le( inputStream );
		contents = istream_read_int32_le( inputStream );
		value = istream_read_int32_le( inputStream );
		source = buffer + offset;
	}

	RGBAImageFlags* image = new RGBAImageFlags( w, h, flags, contents, value );

	byte* dest = image->getRGBAPixels();
	byte* end = source + ( w * h );
	for (; source != end; ++source, dest += 4 )
	{
		*( dest + 0 ) = palette[*source * 3 + 0];
		*( dest + 1 ) = palette[*source * 3 + 1];
		*( dest + 2 ) = palette[*source * 3 + 2];
		*( dest + 3 ) = 255;
	}

	return image;
}

Image* LoadWal( ArchiveFile& file ){
	ScopedArchiveBuffer buffer( file );
	return LoadMipTex( buffer.buffer, QUAKE2_WAL );
}

Image* LoadM8( ArchiveFile& file ){
	ScopedArchiveBuffer buffer( file );
	return LoadMipTex( buffer.buffer, HERETIC2_M8 );
}