/*
 * Copyright 2004-2008, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef READ_HELPER_H
#define READ_HELPER_H


#include "TIFF.h"

#include <BufferIO.h>
#include <ByteOrder.h>


template<class T>
inline void
byte_swap(T &/*data*/)
{
	// Specialize for data types which actually swap
//	printf("DEAD MEAT!\n");
//	exit(1);
}


template<>
inline void
byte_swap(float &data)
{
	data = __swap_float(data);
}


template<>
inline void
byte_swap(int32 &data)
{
	data = __swap_int32(data);
}


template<>
inline void
byte_swap(uint32 &data)
{
	data = __swap_int32(data);
}


template<>
inline void
byte_swap(int16 &data)
{
	data = __swap_int16(data);
}


template<>
inline void
byte_swap(uint16 &data)
{
	data = __swap_int16(data);
}


class TReadHelper {
	public:
		TReadHelper(BPositionIO& stream)
			:
			fStream(&stream, 65536, false),
			fError(B_OK),
			fSwap(false)
		{
		}

		template<class T> inline void
		operator()(T &data)
		{
			fError = fStream.Read((void *)&data, sizeof(T));
			if (fError >= B_OK) {
				if (IsSwapping())
					byte_swap(data);
				return;
			}

			if (fError == 0)
				fError = B_ERROR;
			throw fError;
		}

		template<class T> inline void
		operator()(T data, size_t length)
		{
			fError = fStream.Read((void *)data, length);
			if (fError < (ssize_t)length)
				fError = B_ERROR;

			if (fError >= B_OK)
				return;

			throw fError;
		}

		template<class T> inline T
		Next()
		{
			T value;
			fError = fStream.Read((void *)&value, sizeof(T));
			if (fError > B_OK) {
				if (IsSwapping())
					byte_swap(value);
				return value;
			}

			if (fError == 0)
				fError = B_ERROR;
			throw fError;
		}

		inline uint32
		Next(uint16 type)
		{
			if (type == TIFF_UINT16_TYPE || type == TIFF_INT16_TYPE)
				return Next<uint16>();

			return Next<uint32>();
		}

		inline double
		NextDouble(uint16 type)
		{
			switch (type) {
				case TIFF_UINT16_TYPE:
					return Next<uint16>();
				case TIFF_UINT32_TYPE:
					return Next<uint32>();
				case TIFF_UFRACTION_TYPE:
				{
					double value = Next<uint32>();
					return value / Next<uint32>();
				}
				case TIFF_INT16_TYPE:
					return Next<int16>();
				case TIFF_INT32_TYPE:
					return Next<int32>();
				case TIFF_FRACTION_TYPE:
				{
					double value = Next<int32>();
					return value / Next<int32>();
				}
				case TIFF_FLOAT_TYPE:
					return Next<float>();
				case TIFF_DOUBLE_TYPE:
					return Next<double>();

				default:
					return Next<uint8>();
			}
		}

		inline void
		NextShorts(uint16* data, size_t length)
		{
			fError = fStream.Read(data, length * 2);
			if (fError < (ssize_t)length * 2)
				fError = B_ERROR;

			if (fError >= B_OK) {
				if (IsSwapping())
					swap_data(B_INT16_TYPE, data, length * 2, B_SWAP_ALWAYS);
				return;
			}

			throw fError;
		}

		status_t Status() const
			{ return fError >= B_OK ? B_OK : fError; };

		off_t Seek(off_t offset, int32 mode)
			{ return fStream.Seek(offset, mode); }
		off_t Position() const
			{ return fStream.Position(); }

		void SetSwap(bool yesNo) { fSwap = yesNo; };
		bool IsSwapping() const { return fSwap; };

		BPositionIO& Stream() { return fStream; }

	private:
		BBufferIO	fStream;
		status_t	fError;
		bool		fSwap;
};

#endif	// READ_HELPER_H