/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	plTextureExportLog - Lil' utility class for collating and writing out	//
//						 a log of all textures exported, or rather, in the	//
//						 resManager, or rather, the ones passed in to this	//
//						 sucker.											//
//																			//
//////////////////////////////////////////////////////////////////////////////

#include "HeadSpin.h"
#include "hsTypes.h"
#include "hsWindows.h"
#include "plTextureExportLog.h"
#include "../plGImage/plCubicEnvironmap.h"
#include "../plGImage/plMipmap.h"
#include "../plGImage/plDynamicTextMap.h"
#include "../plPipeline/plRenderTarget.h"
#include "../plPipeline/plCubicRenderTarget.h"
#include "../pnKeyedObject/plKey.h"
#include "hsUtils.h"
#include "hsStream.h"


//// Constructor/Destructor //////////////////////////////////////////////////

plTextureExportLog::plTextureExportLog( const char *fileName )
{
	fFileName = hsStrcpy( fileName );
	fNodeList = nil;
}

plTextureExportLog::~plTextureExportLog()
{
	plBMapNode	*node;


	if( fFileName != nil )
	{
		Write();
		delete [] fFileName;
	}

	while( fNodeList != nil )
	{
		node = fNodeList->fNextNode;
		delete fNodeList;
		fNodeList = node;
	}
}

//// Other Ones //////////////////////////////////////////////////////////////

void	plTextureExportLog::IAddBMapNode( UInt32 rank, plBitmap *bMap )
{
	plBMapNode	*node = TRACKED_NEW plBMapNode, **nodeHdl;


	node->fBitmap = bMap;
	node->fRank = rank;


	for( nodeHdl = &fNodeList; *nodeHdl != nil; )
	{
		if( (*nodeHdl)->fRank < rank )
			break;

		nodeHdl = &( (*nodeHdl)->fNextNode );
	}

	node->fNextNode = *nodeHdl;
	*nodeHdl = node;
}

void	plTextureExportLog::AddTexture( plBitmap *texture )
{
	// Rank based on size written to disk
	IAddBMapNode( texture->GetTotalSize(), texture );
}

void	plTextureExportLog::Write( void )
{
	plBMapNode		*node;
	hsUNIXStream	*stream = TRACKED_NEW hsUNIXStream;
	char			str[ 128 ];
	UInt32			size;


	stream->Open( fFileName, "wt" );
	stream->WriteString( "------------------------------------------------------------\n" );
	stream->WriteString( "- Texture Export Data Log                                  -\n" );
	stream->WriteString( "------------------------------------------------------------\n" );
	stream->WriteString( "\n" );
	IWriteTabbedString( stream, "Name", 4 );
	IWriteTabbedString( stream, "Size", 3 );
	IWriteTabbedString( stream, "Type", 4 );
	stream->WriteString( "\n" );
	stream->WriteString( "------------------------------------------------------------\n" );

	for( node = fNodeList; node != nil; node = node->fNextNode )
	{
		plMipmap			*mip = plMipmap::ConvertNoRef( node->fBitmap );
		plDynamicTextMap	*dynText = plDynamicTextMap::ConvertNoRef( node->fBitmap );
		plCubicEnvironmap	*cubic = plCubicEnvironmap::ConvertNoRef( node->fBitmap );
		plCubicRenderTarget*		cubeRend = plCubicRenderTarget::ConvertNoRef( node->fBitmap );
		plRenderTarget*		rend = plRenderTarget::ConvertNoRef( node->fBitmap );

		// Name
		IWriteTabbedString( stream, node->fBitmap->GetKeyName(), dynText != nil ? 8 : 4 );

		// Size, formatted
		size = node->fBitmap->GetTotalSize();
		if( size < 1024 )
		{
			sprintf( str, "%d bytes", size );
			IWriteTabbedString( stream, str, 2 ); 
		}
		else if( size < 1024 * 1024 )
		{
			sprintf( str, "%4.1f kb", size / 1024.f );
			IWriteTabbedString( stream, str, 2 ); 
		}
		else
		{
			sprintf( str, "%4.1f Mb", size / ( 1024.f * 1024.f ) );
			IWriteTabbedString( stream, str, 2 ); 
		}

		if( dynText != nil )
		{
			IWriteTabbedString( stream, "Dynamic text map", 3 );

			// Dimensions
			sprintf( str, "%d by %d", dynText->GetVisibleWidth(), dynText->GetVisibleHeight() );
			IWriteTabbedString( stream, str, 2 );

			sprintf( str, "%d bpp", dynText->GetPixelSize() );
			IWriteTabbedString( stream, str, 1 );

			IWriteTabbedString( stream, dynText->IsCompressed() 
										? "Compressed" 
										: dynText->fCompressionType == plBitmap::kJPEGCompression
											? "JPEG"
											: "Uncompressed", 2 );
		}
		else if( cubic != nil )
		{
			IWriteTabbedString( stream, "Cubic EnvironMap", 3 );

			sprintf( str, "%d pixels square", cubic->GetFace( 0 )->GetWidth() );
			IWriteTabbedString( stream, str, 2 );

			sprintf( str, "%d bpp", cubic->GetPixelSize() );
			IWriteTabbedString( stream, str, 1 );

			IWriteTabbedString( stream, cubic->IsCompressed() 
										? "Compressed" 
										: cubic->fCompressionType == plBitmap::kJPEGCompression
											? "JPEG"
											: "Uncompressed", 2 );
		}
		else if( mip != nil )
		{
			IWriteTabbedString( stream, "Mipmap", 3 );

			// Dimensions & num mip levels
			sprintf( str, "%d by %d", mip->GetWidth(), mip->GetHeight() );
			IWriteTabbedString( stream, str, 2 );

			sprintf( str, "%d bpp", mip->GetPixelSize() );
			IWriteTabbedString( stream, str, 1 );

			sprintf( str, "%d levels", mip->GetNumLevels() );
			IWriteTabbedString( stream, str, 2 );

			IWriteTabbedString( stream, mip->IsCompressed() 
										? "Compressed" 
										: mip->fCompressionType == plBitmap::kJPEGCompression
											? "JPEG"
											: "Uncompressed", 2 );
		}
		else if( cubeRend )
		{
			IWriteTabbedString( stream, "CubicRenderTarget", 3 );

			// Dimensions & num mip levels
			sprintf( str, "%d by %d", cubeRend->GetWidth(), cubeRend->GetHeight() );
			IWriteTabbedString( stream, str, 2 );
		}
		else if( rend )
		{
			IWriteTabbedString( stream, "RenderTarget", 3 );

			// Dimensions & num mip levels
			sprintf( str, "%d by %d", rend->GetWidth(), rend->GetHeight() );
			IWriteTabbedString( stream, str, 2 );
		}
		else
		{
			IWriteTabbedString( stream, "Unknown", 3 );
		}
		stream->WriteString( "\n" );
	}

	stream->Close();
	delete stream;

	// HACK: Prevent the destructor from writing out now
	delete [] fFileName;
	fFileName = nil;
}

void	plTextureExportLog::IWriteTabbedString( hsStream *stream, const char *string, Int8 numTabs )
{
	static char	tabs[ 64 ];
	int			i;


	stream->WriteString( string );

	// Assumes 8 spaces per tab
	numTabs -= strlen( string ) / 8;
	if( numTabs < 1 )
		numTabs = 1;

	for( i = 0; i < numTabs; i++ )
		tabs[ i ] = '\t';
	tabs[ i ] = 0;

	stream->WriteString( tabs );
}