/**************************************************************
 * 
 * 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_forms.hxx"
#include "limitedformats.hxx"
#include "services.hxx"
#include <osl/diagnose.h>
#include <comphelper/types.hxx>
#include <comphelper/extract.hxx>
#include <com/sun/star/form/FormComponentType.hpp>

//.........................................................................
namespace frm
{
//.........................................................................

	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::util;
	using namespace ::com::sun::star::lang;
	using namespace ::com::sun::star::form;
	using namespace ::com::sun::star::beans;

	sal_Int32								OLimitedFormats::s_nInstanceCount(0);
	::osl::Mutex							OLimitedFormats::s_aMutex;
	Reference< XNumberFormatsSupplier >		OLimitedFormats::s_xStandardFormats;

	//=====================================================================
	//=
	//=====================================================================
	//---------------------------------------------------------------------
	enum LocaleType
	{
		ltEnglishUS,
		ltGerman,
		ltSystem
	};

	//---------------------------------------------------------------------
	static const Locale& getLocale(LocaleType _eType)
	{
		static const Locale s_aEnglishUS( ::rtl::OUString::createFromAscii("en"), ::rtl::OUString::createFromAscii("us"), ::rtl::OUString() );
		static const Locale s_aGerman( ::rtl::OUString::createFromAscii("de"), ::rtl::OUString::createFromAscii("DE"), ::rtl::OUString() );
		static const ::rtl::OUString s_sEmptyString;
		static const Locale s_aSystem( s_sEmptyString, s_sEmptyString, s_sEmptyString );

		switch (_eType)
		{
			case ltEnglishUS:
				return s_aEnglishUS;

			case ltGerman:
				return s_aGerman;

			case ltSystem:
				return s_aSystem;
		}

		OSL_ENSURE(sal_False, "getLocale: invalid enum value!");
		return s_aSystem;
	}

	//---------------------------------------------------------------------
	struct FormatEntry
	{
		const sal_Char* pDescription;
		sal_Int32		nKey;
		LocaleType		eLocale;
	};

	//---------------------------------------------------------------------
	static const FormatEntry* lcl_getFormatTable(sal_Int16 nTableId)
	{
		switch (nTableId)
		{
			case FormComponentType::TIMEFIELD:
			{
				static FormatEntry s_aFormats[] = {
					{ "HH:MM", -1, ltEnglishUS },
					{ "HH:MM:SS", -1, ltEnglishUS },
					{ "HH:MM AM/PM", -1, ltEnglishUS },
					{ "HH:MM:SS AM/PM", -1, ltEnglishUS },
					{ NULL, -1, ltSystem }
				};
				// don't switch this table here to const. The compiler could be tempted to really place this
				// in a non-writeable segment, but we want to fill in the format keys later ....
				return s_aFormats;
			}
			case FormComponentType::DATEFIELD:
			{
				static FormatEntry s_aFormats[] = {
					{ "T-M-JJ", -1, ltGerman },
					{ "TT-MM-JJ", -1, ltGerman },
					{ "TT-MM-JJJJ", -1, ltGerman },
					{ "NNNNT. MMMM JJJJ", -1, ltGerman },

					{ "DD/MM/YY", -1, ltEnglishUS },
					{ "MM/DD/YY", -1, ltEnglishUS },
					{ "YY/MM/DD", -1, ltEnglishUS },
					{ "DD/MM/YYYY", -1, ltEnglishUS },
					{ "MM/DD/YYYY", -1, ltEnglishUS },
					{ "YYYY/MM/DD", -1, ltEnglishUS },

					{ "JJ-MM-TT", -1, ltGerman },
					{ "JJJJ-MM-TT", -1, ltGerman },

					{ NULL, -1, ltSystem }
				};
				return s_aFormats;
			}
		}

		OSL_ENSURE(sal_False, "lcl_getFormatTable: invalid id!");
		return NULL;
	}

	//=====================================================================
	//= OLimitedFormats
	//=====================================================================
	//---------------------------------------------------------------------
	OLimitedFormats::OLimitedFormats(const Reference< XMultiServiceFactory >& _rxORB, const sal_Int16 _nClassId)
		:m_nFormatEnumPropertyHandle(-1)
        ,m_nTableId(_nClassId)
	{
		OSL_ENSURE(_rxORB.is(), "OLimitedFormats::OLimitedFormats: invalid service factory!");
		acquireSupplier(_rxORB);
		ensureTableInitialized(m_nTableId);
	}

	//---------------------------------------------------------------------
	OLimitedFormats::~OLimitedFormats()
	{
		releaseSupplier();
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::ensureTableInitialized(const sal_Int16 _nTableId)
	{
		const FormatEntry* pFormatTable = lcl_getFormatTable(_nTableId);
		if (-1 == pFormatTable->nKey)
		{
			::osl::MutexGuard aGuard(s_aMutex);
			if (-1 == pFormatTable->nKey)
			{
				// initialize the keys
				Reference<XNumberFormats> xStandardFormats;
				if (s_xStandardFormats.is())
					xStandardFormats = s_xStandardFormats->getNumberFormats();
				OSL_ENSURE(xStandardFormats.is(), "OLimitedFormats::ensureTableInitialized: don't have a formats supplier!");

				if (xStandardFormats.is())
				{
					// loop through the table
					FormatEntry* pLoopFormats = const_cast<FormatEntry*>(pFormatTable);
					while (pLoopFormats->pDescription)
					{
						// get the key for the description
						pLoopFormats->nKey = xStandardFormats->queryKey(
							::rtl::OUString::createFromAscii(pLoopFormats->pDescription),
							getLocale(pLoopFormats->eLocale),
							sal_False
						);

						if (-1 == pLoopFormats->nKey)
						{
							pLoopFormats->nKey = xStandardFormats->addNew(
								::rtl::OUString::createFromAscii(pLoopFormats->pDescription),
								getLocale(pLoopFormats->eLocale)
							);
#ifdef DBG_UTIL
							try
							{
								xStandardFormats->getByKey(pLoopFormats->nKey);
							}
							catch(const Exception&)
							{
								OSL_ENSURE(sal_False, "OLimitedFormats::ensureTableInitialized: adding the key to the formats collection failed!");
							}
#endif
						}

						// next
						++pLoopFormats;
					}
				}
			}
		}
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::clearTable(const sal_Int16 _nTableId)
	{
		::osl::MutexGuard aGuard(s_aMutex);
		const FormatEntry* pFormats = lcl_getFormatTable(_nTableId);
		FormatEntry* pResetLoop = const_cast<FormatEntry*>(pFormats);
		while (pResetLoop->pDescription)
		{
			pResetLoop->nKey = -1;
			++pResetLoop;
		}
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::setAggregateSet(const Reference< XFastPropertySet >& _rxAggregate, sal_Int32 _nOriginalPropertyHandle)
	{
		// changes (NULL -> not NULL) and (not NULL -> NULL) are allowed
		OSL_ENSURE(!m_xAggregate.is() || !_rxAggregate.is(), "OLimitedFormats::setAggregateSet: already have an aggregate!");
		OSL_ENSURE(_rxAggregate.is() || m_xAggregate.is(), "OLimitedFormats::setAggregateSet: invalid new aggregate!");

		m_xAggregate = _rxAggregate;
		m_nFormatEnumPropertyHandle = _nOriginalPropertyHandle;
#ifdef DBG_UTIL
		if (m_xAggregate.is())
		{
			try
			{
				m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
			}
			catch(const Exception&)
			{
				OSL_ENSURE(sal_False, "OLimitedFormats::setAggregateSet: invalid handle!");
			}
		}
#endif
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::getFormatKeyPropertyValue( Any& _rValue ) const
	{
		_rValue.clear();

		OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::getFormatKeyPropertyValue: not initialized!");
		if (m_xAggregate.is())
		{
			// get the aggregate's enum property value
			Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
			sal_Int32 nValue = -1;
			::cppu::enum2int(nValue, aEnumPropertyValue);

			// get the translation table
			const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);

			// seek to the nValue'th entry
			sal_Int32 nLookup = 0;
			for	(	;
					(NULL != pFormats->pDescription) && (nLookup < nValue);
					++pFormats, ++nLookup
				)
				;
			OSL_ENSURE(NULL != pFormats->pDescription, "OLimitedFormats::getFormatKeyPropertyValue: did not find the value!");
			if (pFormats->pDescription)
				_rValue <<= pFormats->nKey;
		}

		// TODO: should use a standard format for the control type we're working for
	}

	//---------------------------------------------------------------------
	sal_Bool OLimitedFormats::convertFormatKeyPropertyValue(Any& _rConvertedValue, Any& _rOldValue, const Any& _rNewValue)
	{
		OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::convertFormatKeyPropertyValue: not initialized!");

		if (m_xAggregate.is())
		{
			// the new format key to set
			sal_Int32 nNewFormat = 0;
			if (!(_rNewValue >>= nNewFormat))
				throw IllegalArgumentException();

			// get the old (enum) value from the aggregate
			Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
			sal_Int32 nOldEnumValue = -1;
			::cppu::enum2int(nOldEnumValue, aEnumPropertyValue);

			// get the translation table
			const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);

			_rOldValue.clear();
			_rConvertedValue.clear();

			// look for the entry with the given format key
			sal_Int32 nTablePosition = 0;
			for	(	;
					(NULL != pFormats->pDescription) && (nNewFormat != pFormats->nKey);
					++pFormats, ++nTablePosition
				)
			{
				if (nTablePosition == nOldEnumValue)
					_rOldValue <<= pFormats->nKey;
			}

			sal_Bool bFoundIt = (NULL != pFormats->pDescription);
			sal_Bool bModified = sal_False;
			if (bFoundIt)
			{
				_rConvertedValue <<= (sal_Int16)nTablePosition;
				bModified = nTablePosition != nOldEnumValue;
			}

			if (!_rOldValue.hasValue())
			{	// did not reach the end of the table (means we found nNewFormat)
				// -> go to the end to ensure that _rOldValue is set
				while (pFormats->pDescription)
				{
					if (nTablePosition == nOldEnumValue)
					{
						_rOldValue <<= pFormats->nKey;
						break;
					}

					++pFormats;
					++nTablePosition;
				}
			}

			OSL_ENSURE(_rOldValue.hasValue(), "OLimitedFormats::convertFormatKeyPropertyValue: did not find the old enum value in the table!");

			if (!bFoundIt)
			{	// somebody gave us an format which we can't translate
				::rtl::OUString sMessage = ::rtl::OUString::createFromAscii("This control supports only a very limited number of formats.");
				throw IllegalArgumentException(sMessage, NULL, 2);
			}

			return bModified;
		}

		return sal_False;
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::setFormatKeyPropertyValue( const Any& _rNewValue )
	{
		OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::setFormatKeyPropertyValue: not initialized!");

		if (m_xAggregate.is())
		{	// this is to be called after convertFormatKeyPropertyValue, where
			// we translated the format key into a enum value.
			// So now we can simply forward this enum value to our aggreate
			m_xAggregate->setFastPropertyValue(m_nFormatEnumPropertyHandle, _rNewValue);
		}
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::acquireSupplier(const Reference< XMultiServiceFactory >& _rxORB)
	{
		::osl::MutexGuard aGuard(s_aMutex);
		if ((1 == ++s_nInstanceCount) && _rxORB.is())
		{	// create the standard formatter

			Sequence< Any > aInit(1);
			aInit[0] <<= getLocale(ltEnglishUS);

			Reference< XInterface > xSupplier = _rxORB->createInstanceWithArguments(FRM_NUMBER_FORMATS_SUPPLIER, aInit);
			OSL_ENSURE(xSupplier.is(), "OLimitedFormats::OLimitedFormats: could not create a formats supplier!");

			s_xStandardFormats = Reference< XNumberFormatsSupplier >(xSupplier, UNO_QUERY);
			OSL_ENSURE(s_xStandardFormats.is() || !xSupplier.is(), "OLimitedFormats::OLimitedFormats: missing an interface!");
		}
	}

	//---------------------------------------------------------------------
	void OLimitedFormats::releaseSupplier()
	{
		::osl::MutexGuard aGuard(s_aMutex);
		if (0 == --s_nInstanceCount)
		{
			::comphelper::disposeComponent(s_xStandardFormats);
			s_xStandardFormats = NULL;

			clearTable(FormComponentType::TIMEFIELD);
			clearTable(FormComponentType::DATEFIELD);
		}
	}

//.........................................................................
}	// namespace frm
//.........................................................................