#include "stdafx.h"
#include "SGameCreditsScene.h"
#include "SGameSceneManager.h"
#include <kfile/KFileManager.h>
#include "KDeviceManager.h"
#include "TemplateUtil.h"
#include "KViewport.h"
#include "SGameMilesSoundMgr.h"
#include "KResourceManager.h"
#include "SLog.h"

rp::SGameCreditsScene::SGameCreditsScene( 
	  SGameSceneManager& sceneMgr
	, SGameScene* parent
	, const char* sceneName
	, DWORD screeningTime
	, DWORD fadeInTime
	, DWORD fadeOutTime
	, DWORD beginScrollTime
	, DWORD endScrollTime
	, float startx
	, DWORD width
	, DWORD height
	, KViewportObject* viewport )
	: SGameScene			( sceneMgr, parent, sceneName )
	, mScreenWidth			( width )
	, mScreenX				( startx )
	, mScreenHeight			( height ) //mSceneMgr.graphics().GetRenderDevice()->GetScreenSize().height )
	, mScreeningTime		( screeningTime - ( fadeInTime + fadeOutTime ))
	, mFadeInTime			( fadeInTime )
	, mFadeOutTime			( fadeOutTime )
	, mBeginScrollTime		( beginScrollTime )
	, mEndScrollTime		( endScrollTime )
	, mShowTime				( 0 )
	, mProjectPosition		( 0 )
	, mFilmLength			( 0 )
	, mFilmIndex			( 0 )
	, mEscapeTime			( 0 )
	, mViewport		( viewport )
{
}

rp::SGameCreditsScene::~SGameCreditsScene()
{
	rp::wipe_seq( mFilms );
}

void rp::SGameCreditsScene::onEnter()
{	
}

void rp::SGameCreditsScene::onActivate()
{
	mShowTime			= 0;
	mProjectPosition	= 0;
	mFilmIndex			= 0;
	mEscapeTime			= 0;

	setLocalVisibility( 0 );

	//mSceneMgr.milesSoundMgr().StopBgm();
	mSceneMgr.milesSoundMgr().StopMusic();

	mSceneMgr.milesSoundMgr().SwapPlayBGM( "05_Pioneer_of_Distorted_Land.ogg", 100, 1000, 1000, false );
}

void rp::SGameCreditsScene::onDeactivate()
{
}

void rp::SGameCreditsScene::onLeave()
{
}

void rp::SGameCreditsScene::onTick()
{
	if( mScreeningTime == 0 )
		return;

	SGameScene::onTick();

	if( mShowTime == 0 ) 
	{
		mShowTime = mSceneMgr.timer().getTime();
	}

	DWORD ScreeningTimeDiff = mSceneMgr.timer().getTime() - mShowTime;

	// fade in -> screening -> fade out
	if( ScreeningTimeDiff < mFadeInTime )
	{
		setLocalVisibility( (float)ScreeningTimeDiff / mFadeInTime );
	}
	else if( ScreeningTimeDiff < ( mFadeInTime + mScreeningTime ) )
	{
		setLocalVisibility( 1.0f );
	}
	else if( ScreeningTimeDiff < ( mFadeInTime + mScreeningTime + mFadeOutTime ) )
	{
		setLocalVisibility( (float)( ( mFadeInTime + mScreeningTime + mFadeOutTime ) - ScreeningTimeDiff ) / mFadeOutTime );
	}
	else
	{
		SGameScene::activate( false );
	}

	// escape process
	if( mEscapeTime != 0 )
	{
		DWORD EscapeTimeDiff = mSceneMgr.timer().getTime() - mEscapeTime;
		if( EscapeTimeDiff < mFadeOutTime )
		{
			setLocalVisibility( ::min( (float)( mFadeOutTime - EscapeTimeDiff ) / mFadeOutTime, getLocalVisibility() ) );
		}
		else
		{
			setLocalVisibility( 0.f );
			SGameScene::activate( false );
		}
	}

	updateVisibility();

	// scrolling projected films
	if( ScreeningTimeDiff < mBeginScrollTime )
	{
		mProjectPosition = 0.f;
	}
	else if( ScreeningTimeDiff < mEndScrollTime )
	{
		DWORD ScrollDuration = mEndScrollTime - mBeginScrollTime;
		DWORD ScrollTimeDiff = ScreeningTimeDiff - mBeginScrollTime;
		mProjectPosition = ( mFilmLength - mScreenHeight ) / (float)ScrollDuration * (float)ScrollTimeDiff;
	}
	else
	{
		mProjectPosition = mFilmLength - mScreenHeight;
	}

	film_vector_t::iterator it = mFilms.begin() + mFilmIndex, end = mFilms.end();
	for( int FilmIndex = mFilmIndex; it != end; ++it, ++FilmIndex )
	{
		CFilm* Film = (*it);
		if( Film && Film->isVisible( mProjectPosition, mScreenHeight ) )
		{
			mFilmIndex = FilmIndex;
			break;
		}
	}
}

void rp::SGameCreditsScene::onRender( KViewportObject* viewport )
{
	film_vector_t::iterator it = mFilms.begin() + mFilmIndex, end = mFilms.end();
	for( ; it != end; ++it )
	{
		CFilm* Film = (*it);
		if( Film && Film->isVisible( mProjectPosition, mScreenHeight ) )
		{
			KSpritePrimitive& FilmPrimitive = Film->project( mScreenX, mProjectPosition, mScreenWidth, mScreenHeight );
			FilmPrimitive.SetVisibility( getWorldVisibility() );

			if( mViewport )
				mViewport->Register( &FilmPrimitive );
			else
				viewport->Register( &FilmPrimitive );
		}
		else
			break;
	}
}

void rp::SGameCreditsScene::addFilm( const char* fileName )
{
	CFilm* Film = new CFilm();
	if( !Film->createFilm( mSceneMgr, fileName, mScreenWidth, mScreenHeight, mFilmLength ) )
	{
		rp::safe_delete( Film );
		return;
	}
	mFilmLength += Film->getFilmHeight();
	mFilms.push_back( Film );
}

void rp::SGameCreditsScene::activate( bool activity )
{
	if( activity == true )
	{
		SGameScene::activate();
	}
	else
	{
		//if( mIsActivated != activity )
		//{
			//if( mEscapeTime == 0 )
			//{
				mEscapeTime = mSceneMgr.timer().getTime();
				mSceneMgr.milesSoundMgr().SwapPlayBGM( "", mFadeOutTime, mFadeOutTime, 100, false );
				SGameScene::activate( false );
			//}
		//}
	}
}

rp::SGameCreditsScene::CFilm::CFilm() : mPosition( 0 )
{
}

bool rp::SGameCreditsScene::CFilm::createFilm( SGameSceneManager& sceneMgr, const char* fileName, int screenWidth, int screenHeight, float position )
{
	NX3LoadPack loadpack;
	loadpack.Init();
	mTexture = sceneMgr.textureMgr().GetTexture( fileName, &loadpack, true, 0 );
	//assert( mTexture && "credits film texture was not loaded!!" );
	if( mTexture == 0 ) 
	{
		SDEBUGLOG( "[Function = %s]", __FUNCTION__);
		SDEBUGLOG("Credit film texture : %s cannot load!!" , fileName);
		return false;
	}

	mSprite = new KResSprite();
	mSprite->SetTexture( mTexture, NULL );
	mSprite->SetSize( (float)screenWidth, (float)mTexture->GetHeight() );
	mSprite->SetAdditiveRenderMode(false);
	mPrimitive.SetRes( mSprite );

	mPosition = position;

#if defined( _DEBUG )
	mFilmName = fileName;
#endif

	return true;
}

float rp::SGameCreditsScene::CFilm::getFilmWidth()
{
	return mSprite->GetSizeX();
}

float rp::SGameCreditsScene::CFilm::getFilmHeight()
{
	return mSprite->GetSizeY();
}

bool rp::SGameCreditsScene::CFilm::isVisible( float screenPosition, int screenHeight )
{
	if( ( screenPosition > ( mPosition + getFilmHeight() ) ) || ( ( screenPosition + screenHeight ) < mPosition ) )
		return false;
	return true;
}

KSpritePrimitive& rp::SGameCreditsScene::CFilm::project( float screenx, float screenPosition, int screenWidth, int screenHeight )
{
	float ProjStartPosition = ::max( mPosition, screenPosition );
	float ProjEndPosition	= ::min( mPosition + getFilmHeight(), screenPosition + screenHeight );
	float UvTop		= ( ProjStartPosition - mPosition ) / getFilmHeight();
	float UvBottom	= ( ProjEndPosition - mPosition ) / getFilmHeight();
	
	mPrimitive.SetPosition( K3DVector( screenx, ProjStartPosition - screenPosition, 0.f ) );
	mPrimitive.SetSourceUVRect( 0.f, UvTop, 1.f, UvBottom );
	mPrimitive.SetTargetSize( (float)screenWidth, ProjEndPosition - ProjStartPosition );

	return mPrimitive;
}