/**************************************************************
 *
 * 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_cppu.hxx"

#include "osl/thread.hxx"
#include "osl/conditn.hxx"
#include "osl/mutex.hxx"

#include "cppu/helper/purpenv/Environment.hxx"
#include "cppu/helper/purpenv/Mapping.hxx"


#ifdef debug
# define LOG_LIFECYCLE_AffineBridge
#endif

#ifdef LOG_LIFECYCLE_AffineBridge
#  include <iostream>
#  define LOG_LIFECYCLE_AffineBridge_emit(x) x

#else
#  define LOG_LIFECYCLE_AffineBridge_emit(x)

#endif

class InnerThread;
class OuterThread;

class SAL_DLLPRIVATE AffineBridge : public cppu::Enterable
{
public:
	enum Msg
	{
		CB_DONE,
		CB_FPOINTER
	};

	Msg                   m_message;
	uno_EnvCallee       * m_pCallee;
	va_list             * m_pParam;

	osl::Mutex            m_innerMutex;
	oslThreadIdentifier   m_innerThreadId;
	InnerThread         * m_pInnerThread;
	osl::Condition        m_innerCondition;
	sal_Int32             m_enterCount;

	osl::Mutex            m_outerMutex;
	oslThreadIdentifier   m_outerThreadId;
	osl::Condition        m_outerCondition;
	OuterThread         * m_pOuterThread;

	explicit  AffineBridge(void);
	virtual  ~AffineBridge(void);

	virtual void  v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam);
	virtual void  v_callOut_v (uno_EnvCallee * pCallee, va_list * pParam);

	virtual void  v_enter(void);
	virtual void  v_leave(void);

	virtual int  v_isValid(rtl::OUString * pReason);

	void innerDispatch(void);
	void outerDispatch(int loop);
};

class SAL_DLLPRIVATE InnerThread : public osl::Thread
{
    virtual void SAL_CALL run(void);

	AffineBridge * m_pAffineBridge;

public:
	InnerThread(AffineBridge * threadEnvironment)
		: m_pAffineBridge(threadEnvironment)
		{
			create();
		}
};

void InnerThread::run(void)
{
	m_pAffineBridge->enter();
	m_pAffineBridge->innerDispatch();
	m_pAffineBridge->leave();
}

class SAL_DLLPRIVATE OuterThread : public osl::Thread
{
    virtual void SAL_CALL run(void);

	AffineBridge * m_pAffineBridge;

public:
	OuterThread(AffineBridge * threadEnvironment);
};

OuterThread::OuterThread(AffineBridge * threadEnvironment)
	: m_pAffineBridge(threadEnvironment)
{
	create();
}

void OuterThread::run(void)
{
	osl::MutexGuard guard(m_pAffineBridge->m_outerMutex);

	m_pAffineBridge->m_outerThreadId = getIdentifier();
	m_pAffineBridge->outerDispatch(0);
	m_pAffineBridge->m_outerThreadId = 0;

	m_pAffineBridge->m_pOuterThread = NULL;
	m_pAffineBridge = NULL;
}


AffineBridge::AffineBridge(void)
	: m_innerThreadId(0),
	  m_pInnerThread (NULL),
	  m_enterCount   (0),
	  m_outerThreadId(0),
	  m_pOuterThread (NULL)
{
	LOG_LIFECYCLE_AffineBridge_emit(fprintf(stderr, "LIFE: %s -> %p\n", "AffineBridge::AffineBridge(uno_Environment * pEnv)", this));
}

AffineBridge::~AffineBridge(void)
{
	LOG_LIFECYCLE_AffineBridge_emit(fprintf(stderr, "LIFE: %s -> %p\n", "AffineBridge::~AffineBridge(void)", this));

	if (m_pInnerThread && osl_getThreadIdentifier(NULL) != m_innerThreadId)
	{
		m_message = CB_DONE;
		m_innerCondition.set();

		m_pInnerThread->join();
	}

	delete m_pInnerThread;

	if (m_pOuterThread)
	{
		m_pOuterThread->join();
		delete m_pOuterThread;
	}
}


void AffineBridge::outerDispatch(int loop)
{
	OSL_ASSERT(m_outerThreadId == osl_getThreadIdentifier(NULL));
	OSL_ASSERT(m_innerThreadId != m_outerThreadId);

	Msg mm;

	do
	{
		// FIXME: created outer thread must not wait
		// in case of no message
		// note: no message can happen in case newly created
		// outer thread acquire outerMutex after a real outer
		// thread enters outerDispatch!
		m_outerCondition.wait();
		m_outerCondition.reset();

		mm = m_message;

		switch(mm)
		{
		case CB_DONE:
			break;

		case CB_FPOINTER:
		{
			m_pCallee(m_pParam);

			m_message = CB_DONE;
			m_innerCondition.set();
			break;
		}
		default:
			abort();
		}
	}
	while(mm != CB_DONE && loop);
}

void AffineBridge::innerDispatch(void)
{
	OSL_ASSERT(m_innerThreadId == osl_getThreadIdentifier(NULL));
	OSL_ASSERT(m_innerThreadId != m_outerThreadId);

	Msg mm;

	do
	{
		m_innerCondition.wait();
		m_innerCondition.reset();

		mm = m_message;

		switch(mm)
		{
		case CB_DONE:
			break;

		case CB_FPOINTER:
		{
			m_pCallee(m_pParam);

			m_message = CB_DONE;
			m_outerCondition.set();
			break;
		}
		default:
			abort();
		}
	}
	while(mm != CB_DONE);
}

void AffineBridge::v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam)
{
	osl::MutexGuard guard(m_outerMutex); // only one thread at a time can call into

	if (m_innerThreadId == 0) // no inner thread yet
	{
		m_pInnerThread  = new InnerThread(this);
		m_pInnerThread->resume();
	}

	bool resetId = false;
	if (!m_outerThreadId)
	{
		m_outerThreadId = osl_getThreadIdentifier(NULL);
		resetId = true;
	}

	m_message = CB_FPOINTER;
	m_pCallee = pCallee;
	m_pParam  = pParam;
	m_innerCondition.set();

	outerDispatch(1);

	if (resetId)
		m_outerThreadId = 0;
}

void AffineBridge::v_callOut_v(uno_EnvCallee * pCallee, va_list * pParam)
{
	OSL_ASSERT(m_innerThreadId);

	osl::MutexGuard guard(m_innerMutex);

	if (m_outerThreadId == 0) // no outer thread yet
	{
		osl::MutexGuard guard_m_outerMutex(m_outerMutex);

		if (m_outerThreadId == 0)
		{
			if (m_pOuterThread)
			{
				m_pOuterThread->join();
				delete m_pOuterThread;
			}

			m_pOuterThread = new OuterThread(this);
		}
	}

	m_message = CB_FPOINTER;
	m_pCallee = pCallee;
	m_pParam  = pParam;
	m_outerCondition.set();

	innerDispatch();
}

void AffineBridge::v_enter(void)
{
	m_innerMutex.acquire();

	if (!m_enterCount)
		m_innerThreadId = osl_getThreadIdentifier(NULL);

	OSL_ASSERT(m_innerThreadId == osl_getThreadIdentifier(NULL));

	++ m_enterCount;
}

void AffineBridge::v_leave(void)
{
	OSL_ASSERT(m_innerThreadId == osl_getThreadIdentifier(NULL));

	-- m_enterCount;
	if (!m_enterCount)
		m_innerThreadId = 0;

	m_innerMutex.release();
}

int  AffineBridge::v_isValid(rtl::OUString * pReason)
{
	int result = 1;

	result = m_enterCount > 0;
	if (!result)
		*pReason = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("not entered"));

	else
	{
		result = m_innerThreadId == osl_getThreadIdentifier(NULL);

		if (!result)
			*pReason = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("wrong thread"));
	}

	if (result)
		*pReason = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OK"));

	return result;
}

extern "C" void SAL_DLLPUBLIC_EXPORT SAL_CALL uno_initEnvironment(uno_Environment * pEnv)
	SAL_THROW_EXTERN_C()
{
    cppu::helper::purpenv::Environment_initWithEnterable(pEnv, new AffineBridge());
}

extern "C" void SAL_DLLPUBLIC_EXPORT SAL_CALL uno_ext_getMapping(uno_Mapping     ** ppMapping,
														uno_Environment  * pFrom,
														uno_Environment  * pTo )
{
	cppu::helper::purpenv::createMapping(ppMapping, pFrom, pTo);
}