/*
   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 "skincache.h"

#include "ifilesystem.h"
#include "iscriplib.h"
#include "iarchive.h"
#include "modelskin.h"

#include <map>

#include "stream/stringstream.h"
#include "generic/callback.h"
#include "container/cache.h"
#include "container/hashfunc.h"
#include "os/path.h"
#include "moduleobservers.h"
#include "modulesystem/singletonmodule.h"
#include "stringio.h"

void parseShaderName( CopiedString& name, const char* token ){
	StringOutputStream cleaned( 256 );
	cleaned << PathCleaned( token );
	name = cleaned.c_str();
}

class Doom3ModelSkin
{
typedef std::map<CopiedString, CopiedString> Remaps;
Remaps m_remaps;
public:
bool parseTokens( Tokeniser& tokeniser ){
	RETURN_FALSE_IF_FAIL( Tokeniser_parseToken( tokeniser, "{" ) );
	tokeniser.nextLine();
	for (;; )
	{
		const char* token = tokeniser.getToken();
		if ( token == 0 ) {
			return false;
		}
		if ( string_equal( token, "}" ) ) {
			tokeniser.nextLine();
			return true;
		}
		else if ( string_equal( token, "model" ) ) {
			//const char* model =
			tokeniser.getToken();
		}
		else
		{
			CopiedString from, to;
			parseShaderName( from, token );

			tokeniser.nextLine(); // hack to handle badly formed skins

			parseShaderName( to, tokeniser.getToken() );

			if ( !string_equal( from.c_str(), to.c_str() ) ) {
				m_remaps.insert( Remaps::value_type( from, to ) );
			}
		}
		tokeniser.nextLine();
	}
}
const char* getRemap( const char* name ) const {
	Remaps::const_iterator i = m_remaps.find( name );
	if ( i != m_remaps.end() ) {
		return ( *i ).second.c_str();
	}
	return "";
}
void forEachRemap( const SkinRemapCallback& callback ) const {
	for ( Remaps::const_iterator i = m_remaps.begin(); i != m_remaps.end(); ++i )
	{
		callback( SkinRemap( ( *i ).first.c_str(), ( *i ).second.c_str() ) );
	}
}
};

class GlobalSkins
{
public:
typedef std::map<CopiedString, Doom3ModelSkin> SkinMap;
SkinMap m_skins;
Doom3ModelSkin g_nullSkin;

Doom3ModelSkin& getSkin( const char* name ){
	SkinMap::iterator i = m_skins.find( name );
	if ( i != m_skins.end() ) {
		return ( *i ).second;
	}

	return g_nullSkin;
}

bool parseTokens( Tokeniser& tokeniser ){
	tokeniser.nextLine();
	for (;; )
	{
		const char* token = tokeniser.getToken();
		if ( token == 0 ) {
			// end of token stream
			return true;
		}
		if ( !string_equal( token, "skin" ) ) {
			Tokeniser_unexpectedError( tokeniser, token, "skin" );
			return false;
		}
		const char* other = tokeniser.getToken();
		if ( other == 0 ) {
			Tokeniser_unexpectedError( tokeniser, token, "#string" );
			return false;
		}
		CopiedString name;
		parseShaderName( name, other );
		Doom3ModelSkin& skin = m_skins[name];
		RETURN_FALSE_IF_FAIL( skin.parseTokens( tokeniser ) );
	}
}

void parseFile( const char* name ){
	StringOutputStream relativeName( 64 );
	relativeName << "skins/" << name;
	ArchiveTextFile* file = GlobalFileSystem().openTextFile( relativeName.c_str() );
	if ( file != 0 ) {
		globalOutputStream() << "parsing skins from " << makeQuoted( name ) << "\n";
		{
			Tokeniser& tokeniser = GlobalScriptLibrary().m_pfnNewSimpleTokeniser( file->getInputStream() );
			parseTokens( tokeniser );
			tokeniser.release();
		}
		file->release();
	}
	else
	{
		globalErrorStream() << "failed to open " << makeQuoted( name ) << "\n";
	}
}

typedef MemberCaller1<GlobalSkins, const char*, &GlobalSkins::parseFile> ParseFileCaller;

void construct(){
	GlobalFileSystem().forEachFile( "skins/", "skin", ParseFileCaller( *this ) );
}

void destroy(){
	m_skins.clear();
}

void realise(){
	construct();
}
void unrealise(){
	destroy();
}
};

GlobalSkins g_skins;


class Doom3ModelSkinCacheElement : public ModelSkin
{
ModuleObservers m_observers;
Doom3ModelSkin* m_skin;
public:
Doom3ModelSkinCacheElement() : m_skin( 0 ){
}
void attach( ModuleObserver& observer ){
	m_observers.attach( observer );
	if ( realised() ) {
		observer.realise();
	}
}
void detach( ModuleObserver& observer ){
	if ( realised() ) {
		observer.unrealise();
	}
	m_observers.detach( observer );
}
bool realised() const {
	return m_skin != 0;
}
void realise( const char* name ){
	ASSERT_MESSAGE( !realised(), "Doom3ModelSkinCacheElement::realise: already realised" );
	m_skin = &g_skins.getSkin( name );
	m_observers.realise();
}
void unrealise(){
	ASSERT_MESSAGE( realised(), "Doom3ModelSkinCacheElement::unrealise: not realised" );
	m_observers.unrealise();
	m_skin = 0;
}
const char* getRemap( const char* name ) const {
	ASSERT_MESSAGE( realised(), "Doom3ModelSkinCacheElement::getRemap: not realised" );
	return m_skin->getRemap( name );
}
void forEachRemap( const SkinRemapCallback& callback ) const {
	ASSERT_MESSAGE( realised(), "Doom3ModelSkinCacheElement::forEachRemap: not realised" );
	m_skin->forEachRemap( callback );
}
};

class Doom3ModelSkinCache : public ModelSkinCache, public ModuleObserver
{
class CreateDoom3ModelSkin
{
Doom3ModelSkinCache& m_cache;
public:
explicit CreateDoom3ModelSkin( Doom3ModelSkinCache& cache )
	: m_cache( cache ){
}
Doom3ModelSkinCacheElement* construct( const CopiedString& name ){
	Doom3ModelSkinCacheElement* skin = new Doom3ModelSkinCacheElement;
	if ( m_cache.realised() ) {
		skin->realise( name.c_str() );
	}
	return skin;
}
void destroy( Doom3ModelSkinCacheElement* skin ){
	if ( m_cache.realised() ) {
		skin->unrealise();
	}
	delete skin;
}
};

typedef HashedCache<CopiedString, Doom3ModelSkinCacheElement, HashString, std::equal_to<CopiedString>, CreateDoom3ModelSkin> Cache;
Cache m_cache;
bool m_realised;

public:
typedef ModelSkinCache Type;
STRING_CONSTANT( Name, "*" );
ModelSkinCache* getTable(){
	return this;
}

Doom3ModelSkinCache() : m_cache( CreateDoom3ModelSkin( *this ) ), m_realised( false ){
	GlobalFileSystem().attach( *this );
}
~Doom3ModelSkinCache(){
	GlobalFileSystem().detach( *this );
}

ModelSkin& capture( const char* name ){
	return *m_cache.capture( name );
}
void release( const char* name ){
	m_cache.release( name );
}

bool realised() const {
	return m_realised;
}
void realise(){
	g_skins.realise();
	m_realised = true;
	for ( Cache::iterator i = m_cache.begin(); i != m_cache.end(); ++i )
	{
		( *i ).value->realise( ( *i ).key.c_str() );
	}
}
void unrealise(){
	m_realised = false;
	for ( Cache::iterator i = m_cache.begin(); i != m_cache.end(); ++i )
	{
		( *i ).value->unrealise();
	}
	g_skins.unrealise();
}
};

class Doom3ModelSkinCacheDependencies : public GlobalFileSystemModuleRef, public GlobalScripLibModuleRef
{
};

typedef SingletonModule<Doom3ModelSkinCache, Doom3ModelSkinCacheDependencies> Doom3ModelSkinCacheModule;

Doom3ModelSkinCacheModule g_Doom3ModelSkinCacheModule;

void Doom3ModelSkinCacheModule_selfRegister( ModuleServer& server ){
	g_Doom3ModelSkinCacheModule.selfRegister();
}