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


#include <osl/time.h>

#include <vos/timer.hxx>
#include <vos/diagnose.hxx>
#include <vos/ref.hxx>
#include <vos/thread.hxx>
#include <vos/conditn.hxx>


/////////////////////////////////////////////////////////////////////////////
//
// Timer manager
//

class OTimerManagerCleanup;

class vos::OTimerManager : public vos::OThread
{
    
public:

    ///
  	OTimerManager();
    
	///
  	~OTimerManager();
    
  	/// register timer
    sal_Bool SAL_CALL registerTimer(vos::OTimer* pTimer);

  	/// unregister timer
    sal_Bool SAL_CALL unregisterTimer(vos::OTimer* pTimer);

  	/// lookup timer
    sal_Bool SAL_CALL lookupTimer(const vos::OTimer* pTimer);

	/// retrieves the "Singleton" TimerManager Instance
	static OTimerManager* SAL_CALL getTimerManager();

    
protected:
    
 	/// worker-function of thread
  	virtual void SAL_CALL run();

    // Checking and triggering of a timer event
    void SAL_CALL checkForTimeout();

    // cleanup Method
    virtual void SAL_CALL onTerminated();
    
  	// sorted-queue data
  	vos::OTimer*		m_pHead;
    // List Protection
    vos::OMutex		m_Lock;
    // Signal the insertion of a timer
    vos::OCondition	m_notEmpty;

    // Synchronize access to OTimerManager
	static vos::OMutex m_Access;

    // "Singleton Pattern"
    static vos::OTimerManager* m_pManager;

    friend class OTimerManagerCleanup;
    
};

using namespace vos;

/////////////////////////////////////////////////////////////////////////////
//
// Timer class
//

VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OTimer, vos),
                        VOS_NAMESPACE(OTimer, vos),
                        VOS_NAMESPACE(OObject, vos), 0);

OTimer::OTimer()
{
	m_TimeOut	  = 0;
	m_Expired     = 0;
	m_RepeatDelta = 0;
  	m_pNext       = 0;
}

OTimer::OTimer(const TTimeValue& Time)
{
	m_TimeOut	  = Time;
	m_RepeatDelta = 0;
	m_Expired     = 0;
  	m_pNext       = 0;

	m_TimeOut.normalize();
}

OTimer::OTimer(const TTimeValue& Time, const TTimeValue& Repeat)
{
	m_TimeOut	  = Time;
	m_RepeatDelta = Repeat;
	m_Expired     = 0;
  	m_pNext       = 0;

	m_TimeOut.normalize();
	m_RepeatDelta.normalize();
}

OTimer::~OTimer()
{
    stop();
}

void OTimer::start()
{
	if (! isTicking())
	{
		if (! m_TimeOut.isEmpty())
			setRemainingTime(m_TimeOut);

		OTimerManager *pManager = OTimerManager::getTimerManager();

		VOS_ASSERT(pManager);

		if ( pManager != 0 )
		{
			pManager->registerTimer(this);
		}
	}
}

void OTimer::stop()
{
	OTimerManager *pManager = OTimerManager::getTimerManager();

	VOS_ASSERT(pManager);

	if ( pManager != 0 )
	{
		pManager->unregisterTimer(this);
	}
}

sal_Bool OTimer::isTicking() const
{
	OTimerManager *pManager = OTimerManager::getTimerManager();

	VOS_ASSERT(pManager);

	if (pManager)
		return pManager->lookupTimer(this);
	else
		return sal_False;

}

sal_Bool OTimer::isExpired() const
{
	TTimeValue Now;

	osl_getSystemTime(&Now);

	return !(Now < m_Expired);
}

sal_Bool OTimer::expiresBefore(const OTimer* pTimer) const
{
	VOS_ASSERT(pTimer);

	if ( pTimer != 0 )
	{
		return m_Expired < pTimer->m_Expired;
	}
	else
	{
		return sal_False;
	}
}

void OTimer::setAbsoluteTime(const TTimeValue& Time)
{
	m_TimeOut     = 0;
	m_Expired     = Time;
	m_RepeatDelta = 0;

	m_Expired.normalize();
}

void OTimer::setRemainingTime(const TTimeValue& Remaining)
{
	osl_getSystemTime(&m_Expired);

	m_Expired.addTime(Remaining);
}

void OTimer::setRemainingTime(const TTimeValue& Remaining, const TTimeValue& Repeat)
{
	osl_getSystemTime(&m_Expired);

	m_Expired.addTime(Remaining);

	m_RepeatDelta = Repeat;
}

void OTimer::addTime(const TTimeValue& Delta)
{
	m_Expired.addTime(Delta);
}

TTimeValue OTimer::getRemainingTime() const
{
	TTimeValue Now;

	osl_getSystemTime(&Now);

	sal_Int32 secs = m_Expired.Seconds - Now.Seconds;

	if (secs < 0)
		return TTimeValue(0, 0);

	sal_Int32 nsecs = m_Expired.Nanosec - Now.Nanosec;

	if (nsecs < 0)
	{
		if (secs > 0)
		{
			secs  -= 1;
			nsecs += 1000000000;
		}
		else
			return TTimeValue(0, 0);
	}

	return TTimeValue(secs, nsecs);
}


/////////////////////////////////////////////////////////////////////////////
//
// Timer manager
//

OMutex vos::OTimerManager::m_Access;
OTimerManager* vos::OTimerManager::m_pManager=0;

OTimerManager::OTimerManager()
{
	OGuard Guard(&m_Access);

	VOS_ASSERT(m_pManager == 0);

	m_pManager = this;

	m_pHead= 0;

	m_notEmpty.reset();

	// start thread
	create();
}

OTimerManager::~OTimerManager()
{
	OGuard Guard(&m_Access);

	if ( m_pManager == this )
		m_pManager = 0;
}

void OTimerManager::onTerminated()
{
    delete this; // mfe: AAARRRGGGHHH!!!
}
    
OTimerManager* OTimerManager::getTimerManager()
{    
	OGuard Guard(&m_Access); 
	
	if (! m_pManager)
		new OTimerManager;

	return (m_pManager);
}	

sal_Bool OTimerManager::registerTimer(OTimer* pTimer)
{
	VOS_ASSERT(pTimer);

	if ( pTimer == 0 )
	{
		return sal_False;
	}
	
	OGuard Guard(&m_Lock);

	// try to find one with equal or lower remaining time.
	OTimer** ppIter = &m_pHead;
	
	while (*ppIter) 
	{
		if (pTimer->expiresBefore(*ppIter))
		{	
			// next element has higher remaining time, 
			// => insert new timer before
			break;
		}
		ppIter= &((*ppIter)->m_pNext);
	} 
  
	// next element has higher remaining time, 
	// => insert new timer before
	pTimer->m_pNext= *ppIter;
	*ppIter = pTimer;
    

	if (pTimer == m_pHead)
	{
		// it was inserted as new head
		// signal it to TimerManager Thread
        m_notEmpty.set();
	}

	return sal_True;
}

sal_Bool OTimerManager::unregisterTimer(OTimer* pTimer)
{
	VOS_ASSERT(pTimer);

	if ( pTimer == 0 )
	{
		return sal_False;
	}
	
	// lock access
	OGuard Guard(&m_Lock);

	OTimer** ppIter = &m_pHead;

	while (*ppIter) 
	{
		if (pTimer == (*ppIter))
		{	
			// remove timer from list
			*ppIter = (*ppIter)->m_pNext;
			return sal_True;
		}
		ppIter= &((*ppIter)->m_pNext);
	} 

	return sal_False;
}

sal_Bool OTimerManager::lookupTimer(const OTimer* pTimer) 
{
	VOS_ASSERT(pTimer);

	if ( pTimer == 0 )
	{
		return sal_False;
	}
	
	// lock access
	OGuard Guard(&m_Lock);

	// check the list
	for (OTimer* pIter = m_pHead; pIter != 0; pIter= pIter->m_pNext)
	{
		if (pIter == pTimer)
        {    
			return sal_True;
        }
	}

	return sal_False;
}

void OTimerManager::checkForTimeout()
{

    m_Lock.acquire();

	if ( m_pHead == 0 )
	{
        m_Lock.release();        
		return;
	}

	OTimer* pTimer = m_pHead;

	if (pTimer->isExpired())
	{
		// remove expired timer
		m_pHead = pTimer->m_pNext;

        pTimer->acquire();
        
		m_Lock.release();
		
		pTimer->onShot();

		// restart timer if specified
		if ( ! pTimer->m_RepeatDelta.isEmpty() )
		{
			TTimeValue Now;

			osl_getSystemTime(&Now);

			Now.Seconds += pTimer->m_RepeatDelta.Seconds;				
			Now.Nanosec += pTimer->m_RepeatDelta.Nanosec;				

			pTimer->m_Expired = Now;

			registerTimer(pTimer);
		}
        pTimer->release();
	}
	else
	{
		m_Lock.release();
	}


	return;
}

void OTimerManager::run() 
{
	setPriority(TPriority_BelowNormal);

	while (schedule())
	{
		TTimeValue		delay;
		TTimeValue*		pDelay=0;

        
		m_Lock.acquire();

		if (m_pHead != 0)
        {
			delay = m_pHead->getRemainingTime();
            pDelay=&delay;
        }
        else
        {
            pDelay=0;
        }
        
        
        m_notEmpty.reset();

        m_Lock.release();

        
        m_notEmpty.wait(pDelay);

        checkForTimeout();
  	}

}


/////////////////////////////////////////////////////////////////////////////
//
// Timer manager cleanup
//

// jbu:
// The timer manager cleanup has been removed (no thread is killed anymore).
// So the thread leaks.
// This will result in a GPF in case the vos-library gets unloaded before
// process termination.
// -> TODO : rewrite this file, so that the timerManager thread gets destroyed,
//           when there are no timers anymore !