//
//  ByteOrderTest.cpp
//
//  Created by Setsu on 7/10/2010.
//  Copyright 2010 RoundSquare Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
// 
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//

//----------------------------------------
//	include
//----------------------------------------
#include <Poco/Logger.h>
#include <Poco/PatternFormatter.h>
#include <Poco/FormattingChannel.h>
#include <Poco/ConsoleChannel.h>
#include <Poco/Format.h>
#include <Poco/TypeList.h>
#include <Poco/String.h>
#include <Poco/ByteOrder.h>

#include <string>

#include "ScopedLogMessage.h"

//----------------------------------------
//	const
//----------------------------------------
#if defined(POCO_ARCH_BIG_ENDIAN)
	const std::string kEndianString = "big-endian";
#else
	const std::string kEndianString = "little-endian";
#endif

enum EIntType
{
	eInt16 = 0
,	eUInt16
,	eInt32
,	eUInt32
#if defined(POCO_HAVE_INT64)
,	eInt64
,	eUInt64
#endif
};

const std::string intName[] =
{
	"Int16 "
,	"UInt16"
,	"Int32 "
,	"UInt32"
#if defined(POCO_HAVE_INT64)
,	"Int64 "
,	"UInt64"
#endif
};

const std::string intFormat[] =
{
	"0x%04?X"
,	"0x%04?X"
,	"0x%08?X"
,	"0x%08?X"
#if defined(POCO_HAVE_INT64)
,	"0x%016?X"
,	"0x%016?X"
#endif
};

enum ETestType
{
	eTestFlipBytes = 0
,	eTestBigEndian
,	eTestLittleEndian
,	eTestNetwork
,	eTestNumKind
};

const std::string testDesc[] =
{
	"flipBytes, flipBytes"
,	"toBigEndian, fromBigEndian"
,	"toLittleEndian, fromLittleEndian"
,	"toNetwork, fromNetwork"
};

//----------------------------------------
//	typedef
//----------------------------------------
typedef Poco::TypeListType<
	Poco::Int16
,	Poco::UInt16
,	Poco::Int32
,	Poco::UInt32
#if defined(POCO_HAVE_INT64)
,	Poco::Int64
,	Poco::UInt64
#endif
>::HeadType IntTypeList;

//----------------------------------------
//	TestCommon
//----------------------------------------
template<EIntType N>
void TestCommon(ScopedLogMessage& msg, int testType)
{
	typedef typename Poco::TypeGetter<N, IntTypeList>::HeadType	IntType;

	typedef IntType (*TestFunc)(IntType norm);
	TestFunc func[] = {	Poco::ByteOrder::flipBytes
					,	Poco::ByteOrder::toBigEndian
					,	Poco::ByteOrder::toLittleEndian
					,	Poco::ByteOrder::toNetwork	};
	TestFunc invt[] = {	Poco::ByteOrder::flipBytes
					,	Poco::ByteOrder::fromBigEndian
					,	Poco::ByteOrder::fromLittleEndian
					,	Poco::ByteOrder::fromNetwork	};

	IntType norm = 0x12;
	IntType converted = (func[testType])(norm);
	IntType inverted = (invt[testType])(converted);

	std::string fmt("   %s fmt -> fmt -> fmt");
	Poco::replaceInPlace(fmt, std::string("fmt"), intFormat[N]);
	msg.Message(Poco::format(fmt.c_str(), intName[N], norm, converted, inverted));
}

//----------------------------------------
//	TestByteOrder
//----------------------------------------
template<EIntType N>
void TestByteOrder(ScopedLogMessage& msg, int testType)
{
	TestCommon<N>(msg, testType);
	TestByteOrder<static_cast<EIntType>(N+1)>(msg, testType);	// recursive call
}

#if defined(POCO_HAVE_INT64)
template<>
void TestByteOrder<eUInt64>(ScopedLogMessage& msg, int testType)
{
	TestCommon<eUInt64>(msg, testType);
}
#else
template<>
void TestByteOrder<eUInt32>(ScopedLogMessage& msg, int testType)
{
	TestCommon<eUInt32>(msg, testType);
}
#endif

//----------------------------------------
//	PrepareConsoleLogger
//----------------------------------------
void PrepareConsoleLogger(const std::string& name, int level=Poco::Message::PRIO_INFORMATION)
{
	Poco::FormattingChannel* pFCConsole = new Poco::FormattingChannel(new Poco::PatternFormatter("%t"));
	pFCConsole->setChannel(new Poco::ConsoleChannel);
	pFCConsole->open();

	Poco::Logger::create(name, pFCConsole, level);
}

//----------------------------------------
//	main
//----------------------------------------
int main(int /*argc*/, char** /*argv*/)
{
	PrepareConsoleLogger(Poco::Logger::ROOT, Poco::Message::PRIO_INFORMATION);

	ScopedLogMessage msg("ByteOrderTest ", "start", "end");

	msg.Message(Poco::format(" This is a %s computer system.", kEndianString));

	for(int i=eTestFlipBytes; i<eTestNumKind; ++i)
	{
		msg.Message(" " + testDesc[i] + ":");
		TestByteOrder<eInt16>(msg, i);
	}

	return 0;
}