/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"

#include <tools/time.hxx>
#include <tools/debug.hxx>

#include <vcl/svapp.hxx>
#include <vcl/timer.hxx>

#include <saltimer.hxx>
#include <svdata.hxx>
#include <salinst.hxx>


// =======================================================================

#define MAX_TIMER_PERIOD	((sal_uLong)0xFFFFFFFF)

// ---------------------
// - TimeManager-Types -
// ---------------------

struct ImplTimerData
{
	ImplTimerData*	mpNext; 		// Pointer to the next Instance
	Timer*			mpSVTimer;		// Pointer to SV Timer instance
	sal_uLong			mnUpdateTime;	// Last Update Time
	sal_uLong			mnTimerUpdate;	// TimerCallbackProcs on stack
	sal_Bool			mbDelete;		// Wurde Timer waehren Update() geloescht
	sal_Bool			mbInTimeout;	// Befinden wir uns im Timeout-Handler
};

// =======================================================================

void Timer::ImplDeInitTimer()
{
	ImplSVData* 	pSVData = ImplGetSVData();
	ImplTimerData*	pTimerData = pSVData->mpFirstTimerData;

	if ( pTimerData )
	{
		do
		{
			ImplTimerData* pTempTimerData = pTimerData;
			if ( pTimerData->mpSVTimer )
			{
				pTimerData->mpSVTimer->mbActive = sal_False;
				pTimerData->mpSVTimer->mpTimerData = NULL;
			}
			pTimerData = pTimerData->mpNext;
			delete pTempTimerData;
		}
		while ( pTimerData );

		pSVData->mpFirstTimerData	= NULL;
		pSVData->mnTimerPeriod		= 0;
        delete pSVData->mpSalTimer;
        pSVData->mpSalTimer = NULL;
	}
}

// -----------------------------------------------------------------------

static void ImplStartTimer( ImplSVData* pSVData, sal_uLong nMS )
{
	if ( !nMS )
		nMS = 1;

	if ( nMS != pSVData->mnTimerPeriod )
	{
		pSVData->mnTimerPeriod = nMS;
		pSVData->mpSalTimer->Start( nMS );
	}
}

// -----------------------------------------------------------------------

void Timer::ImplTimerCallbackProc()
{
	ImplSVData* 	pSVData = ImplGetSVData();
	ImplTimerData*	pTimerData;
	ImplTimerData*	pPrevTimerData;
	sal_uLong			nMinPeriod = MAX_TIMER_PERIOD;
	sal_uLong			nDeltaTime;
	sal_uLong			nTime = Time::GetSystemTicks();

	if ( pSVData->mbNoCallTimer )
		return;

	pSVData->mnTimerUpdate++;
	pSVData->mbNotAllTimerCalled = sal_True;

	// Suche Timer raus, wo der Timeout-Handler gerufen werden muss
	pTimerData = pSVData->mpFirstTimerData;
	while ( pTimerData )
	{
		// Wenn Timer noch nicht neu ist und noch nicht geloescht wurde
		// und er sich nicht im Timeout-Handler befindet,
		// dann den Handler rufen, wenn die Zeit abgelaufen ist
		if ( (pTimerData->mnTimerUpdate < pSVData->mnTimerUpdate) &&
			 !pTimerData->mbDelete && !pTimerData->mbInTimeout )
		{
			// Zeit abgelaufen
			if ( (pTimerData->mnUpdateTime+pTimerData->mpSVTimer->mnTimeout) <= nTime )
			{
				// Neue Updatezeit setzen
				pTimerData->mnUpdateTime = nTime;

				// kein AutoTimer, dann anhalten
				if ( !pTimerData->mpSVTimer->mbAuto )
				{
					pTimerData->mpSVTimer->mbActive = sal_False;
					pTimerData->mbDelete = sal_True;
				}

				// call Timeout
				pTimerData->mbInTimeout = sal_True;
				pTimerData->mpSVTimer->Timeout();
				pTimerData->mbInTimeout = sal_False;
			}
		}

		pTimerData = pTimerData->mpNext;
	}

	// Neue Zeit ermitteln
	sal_uLong nNewTime = Time::GetSystemTicks();
	pPrevTimerData = NULL;
	pTimerData = pSVData->mpFirstTimerData;
	while ( pTimerData )
	{
		// Befindet sich Timer noch im Timeout-Handler, dann ignorieren
		if ( pTimerData->mbInTimeout )
		{
			pPrevTimerData = pTimerData;
			pTimerData = pTimerData->mpNext;
		}
		// Wurde Timer zwischenzeitlich zerstoert ?
		else if ( pTimerData->mbDelete )
		{
			if ( pPrevTimerData )
				pPrevTimerData->mpNext = pTimerData->mpNext;
			else
				pSVData->mpFirstTimerData = pTimerData->mpNext;
			if ( pTimerData->mpSVTimer )
				pTimerData->mpSVTimer->mpTimerData = NULL;
			ImplTimerData* pTempTimerData = pTimerData;
			pTimerData = pTimerData->mpNext;
			delete pTempTimerData;
		}
		else
		{
			pTimerData->mnTimerUpdate = 0;
			// kleinste Zeitspanne ermitteln
			if ( pTimerData->mnUpdateTime == nTime )
			{
				nDeltaTime = pTimerData->mpSVTimer->mnTimeout;
				if ( nDeltaTime < nMinPeriod )
					nMinPeriod = nDeltaTime;
			}
			else
			{
				nDeltaTime = pTimerData->mnUpdateTime + pTimerData->mpSVTimer->mnTimeout;
				if ( nDeltaTime < nNewTime )
					nMinPeriod = 1;
				else
				{
					nDeltaTime -= nNewTime;
					if ( nDeltaTime < nMinPeriod )
						nMinPeriod = nDeltaTime;
				}
			}
			pPrevTimerData = pTimerData;
			pTimerData = pTimerData->mpNext;
		}
	}

	// Wenn keine Timer mehr existieren, dann Clock loeschen
	if ( !pSVData->mpFirstTimerData )
	{
        pSVData->mpSalTimer->Stop();
		pSVData->mnTimerPeriod = MAX_TIMER_PERIOD;
	}
	else
		ImplStartTimer( pSVData, nMinPeriod );

	pSVData->mnTimerUpdate--;
	pSVData->mbNotAllTimerCalled = sal_False;
}

// =======================================================================

Timer::Timer()
{
	mpTimerData 	= NULL;
	mnTimeout		= 1;
	mbAuto			= sal_False;
	mbActive		= sal_False;
}

// -----------------------------------------------------------------------

Timer::Timer( const Timer& rTimer )
{
	mpTimerData 	= NULL;
	mnTimeout		= rTimer.mnTimeout;
	mbAuto			= sal_False;
	mbActive		= sal_False;
	maTimeoutHdl	= rTimer.maTimeoutHdl;

	if ( rTimer.IsActive() )
		Start();
}

// -----------------------------------------------------------------------

Timer::~Timer()
{
	if ( mpTimerData )
	{
		mpTimerData->mbDelete = sal_True;
		mpTimerData->mpSVTimer = NULL;
	}
}

// -----------------------------------------------------------------------

void Timer::Timeout()
{
	maTimeoutHdl.Call( this );
}

// -----------------------------------------------------------------------

void Timer::SetTimeout( sal_uLong nNewTimeout )
{
	mnTimeout = nNewTimeout;

	// Wenn Timer aktiv, dann Clock erneuern
	if ( mbActive )
	{
		ImplSVData* pSVData = ImplGetSVData();
		if ( !pSVData->mnTimerUpdate && (mnTimeout < pSVData->mnTimerPeriod) )
			ImplStartTimer( pSVData, mnTimeout );
	}
}

// -----------------------------------------------------------------------

void Timer::Start()
{
	mbActive = sal_True;

	ImplSVData* pSVData = ImplGetSVData();
	if ( !mpTimerData )
	{
		if ( !pSVData->mpFirstTimerData )
		{
			pSVData->mnTimerPeriod = MAX_TIMER_PERIOD;
            if( ! pSVData->mpSalTimer )
            {
                pSVData->mpSalTimer = pSVData->mpDefInst->CreateSalTimer();
                pSVData->mpSalTimer->SetCallback( ImplTimerCallbackProc );
            }
		}

		// insert timer and start
		mpTimerData 				= new ImplTimerData;
		mpTimerData->mpSVTimer		= this;
		mpTimerData->mnUpdateTime	= Time::GetSystemTicks();
		mpTimerData->mnTimerUpdate	= pSVData->mnTimerUpdate;
		mpTimerData->mbDelete		= sal_False;
		mpTimerData->mbInTimeout	= sal_False;

		// !!!!! Wegen SFX hinten einordnen !!!!!
		ImplTimerData* pPrev = NULL;
		ImplTimerData* pData = pSVData->mpFirstTimerData;
		while ( pData )
		{
			pPrev = pData;
			pData = pData->mpNext;
		}
		mpTimerData->mpNext = NULL;
		if ( pPrev )
			pPrev->mpNext = mpTimerData;
		else
			pSVData->mpFirstTimerData = mpTimerData;

		if ( mnTimeout < pSVData->mnTimerPeriod )
			ImplStartTimer( pSVData, mnTimeout );
	}
	else if( !mpTimerData->mpSVTimer ) // TODO: remove when guilty found
	{
		DBG_ERROR( "Timer::Start() on a destroyed Timer!" );
	}
	else
	{
		mpTimerData->mnUpdateTime	 = Time::GetSystemTicks();
		mpTimerData->mnTimerUpdate	 = pSVData->mnTimerUpdate;
		mpTimerData->mbDelete		 = sal_False;
	}
}

// -----------------------------------------------------------------------

void Timer::Stop()
{
	mbActive = sal_False;

	if ( mpTimerData )
		mpTimerData->mbDelete = sal_True;
}

// -----------------------------------------------------------------------

Timer& Timer::operator=( const Timer& rTimer )
{
	if ( IsActive() )
		Stop();

	mbActive		= sal_False;
	mnTimeout		= rTimer.mnTimeout;
	maTimeoutHdl	= rTimer.maTimeoutHdl;

	if ( rTimer.IsActive() )
		Start();

	return *this;
}

// =======================================================================

AutoTimer::AutoTimer()
{
	mbAuto = sal_True;
}

// -----------------------------------------------------------------------

AutoTimer::AutoTimer( const AutoTimer& rTimer ) : Timer( rTimer )
{
	mbAuto = sal_True;
}

// -----------------------------------------------------------------------

AutoTimer& AutoTimer::operator=( const AutoTimer& rTimer )
{
	Timer::operator=( rTimer );
	return *this;
}