/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#include "ExifBuilder.hpp"

#define ARRAY_COUNT(Array) (sizeof(Array) / sizeof(*Array))

namespace
{
	char EXIF_HEADER_AND_PADDING[] = {'E', 'x', 'i', 'f', 0, 0};
	int const EXIF_HEADER_SIZE = ARRAY_COUNT(EXIF_HEADER_AND_PADDING);

	char TIFF_HEADER[] = {0x4d, 0x4d, 0, 0x2a};
	int const TIFF_HEADER_SIZE = ARRAY_COUNT(TIFF_HEADER);

	enum class IFDTag : uint16_t
	{
		END = 0,
		MAKE = 0x010f,
		MODEL = 0x0110,
		ORIENTATION = 0x0112,
		XRESOLUTION = 0x011a,
		YRESOLUTION = 0x011b,
		RESOLUTION_UNIT = 0x0128,
		SOFTWARE_USED = 0x0131,
		DATE_TAKEN = 0x0132,
		EXPOSURE_TIME = 0x829a,
		GPS_INFO_OFFSET = 0x8825,
	};

	enum class IFDValueType
	{
		BYTE = 1,
		ASCII = 2,
		SHORT = 3,
		LONG_ = 4,
		RATIONAL = 5,
	};

	uint32_t endianSwap(uint32_t Value)
	{
		uint32_t Result;

		char *Ptr = (char *)&Value;
		char *Out = (char *)&Result;
		Out[0] = Ptr[3];
		Out[1] = Ptr[2];
		Out[2] = Ptr[1];
		Out[3] = Ptr[0];

		return Result;
	}

	uint16_t endianSwap(uint16_t Value)
	{
		uint16_t Result;

		char *Ptr = (char *)&Value;
		char *Out = (char *)&Result;
		Out[0] = Ptr[1];
		Out[1] = Ptr[0];

		return Result;
	}

	int appendU8(std::vector<uint8_t>& array, uint8_t value)
	{
		int result = array.size();
		array.push_back(value);
		return result;
	}

	int appendU16(std::vector<uint8_t>& array, uint16_t value, bool endianSwap = false)
	{
		int result = array.size();

		if(endianSwap)
			value = ::endianSwap(value);

		char *src = (char *)&value;
		array.push_back(src[0]);
		array.push_back(src[1]);

		return result;
	}

	int appendU32(std::vector<uint8_t>& array, uint32_t value, bool endianSwap = false)
	{
		int result = array.size();

		if(endianSwap)
			value = ::endianSwap(value);

		char *src = (char *)&value;
		array.push_back(src[0]);
		array.push_back(src[1]);
		array.push_back(src[2]);
		array.push_back(src[3]);

		return result;
	}

	int appendVector(std::vector<uint8_t>& array, std::vector<uint8_t> values)
	{
		int result = array.size();

		for(auto value : values)
		{
			array.push_back(value);
		}

		return result;
	}

	int appendVector(std::vector<uint8_t>& array, char* values, int count)
	{
		int result = array.size();

		for(int i = 0; i < count; ++i)
		{
			array.push_back(values[i]);
		}

		return result;
	}

	int appendRational(std::vector<uint8_t>& array, const OpenVulkano::Image::RationalValue& rational, bool endianSwap = false)
	{
		int result = array.size();

		appendU32(array, rational.nominator, endianSwap);
		appendU32(array, rational.denominator, endianSwap);

		return result;
	}

	int appendGPSCoords(std::vector<uint8_t>& array, const OpenVulkano::Image::GPSCoords& coords, bool endianSwap = false)
	{
		int result = array.size();

		appendU32(array, coords.degrees, endianSwap);
		appendU32(array, 1, endianSwap);

		appendU32(array, coords.minutes, endianSwap);
		appendU32(array, 1, endianSwap);

		appendU32(array, coords.seconds, endianSwap);
		appendU32(array, 1, endianSwap);

		return result;
	}
}

namespace OpenVulkano::Image
{
	std::vector<uint8_t> ExifBuilder::build()
	{
		std::vector<uint8_t> result;
		std::vector<uint8_t> data; // the data that has ascii values

		appendVector(result, EXIF_HEADER_AND_PADDING, EXIF_HEADER_SIZE);
		appendVector(result, TIFF_HEADER, TIFF_HEADER_SIZE);

		int numberOfMainTags = 1; // 1 is for GPS Info tag
		numberOfMainTags += orientation != 0;
		numberOfMainTags += make != "";
		numberOfMainTags += model != "";
		numberOfMainTags += xresolution.nominator || xresolution.denominator;
		numberOfMainTags += yresolution.nominator || yresolution.denominator;
		numberOfMainTags += resolutionUnit != 0;
		numberOfMainTags += exposureTime.nominator || exposureTime.denominator;
		numberOfMainTags += softwareUsed != "";
		numberOfMainTags += dateTaken != "";

		appendU32(result, 8, true); // append offset to the ifd
		appendU16(result, numberOfMainTags, true);

		// offsets in result array where the offset to the data should be stored
		int makeOffset = 0;
		int modelOffset = 0;
		int dateTakenOffset = 0;
		int softwareUsedOffset = 0;
		int gpsInfoOffset = 0;

		// Make
		if(make != "")
		{
			appendU16(result, (uint16_t)IFDTag::MAKE, true);
			appendU16(result, (uint16_t)IFDValueType::ASCII, true);
			appendU32(result, make.size() + 1, true);
			makeOffset = appendU32(result, data.size() + 1, true);
			int offsetInData = appendVector(data, (char *)make.c_str(), make.size() + 1);
			uint32_t* ptr = (uint32_t *)(result.data() + makeOffset);
			*ptr = offsetInData;
		}

		// Model
		if(model != "")
		{
			appendU16(result, (uint16_t)IFDTag::MODEL, true);
			appendU16(result, (uint16_t)IFDValueType::ASCII, true);
			appendU32(result, model.size() + 1, true);
			modelOffset = appendU32(result, data.size() + 1, true);
			int offsetInData = appendVector(data, (char *)model.c_str(), model.size() + 1);
			uint32_t* ptr = (uint32_t *)(result.data() + modelOffset);
			*ptr = offsetInData;
		}

		// Orientation
		if(orientation != 0)
		{
			appendU16(result, (uint16_t)IFDTag::ORIENTATION, true);
			appendU16(result, (uint16_t)IFDValueType::SHORT, true);
			appendU32(result, 1, true);
			appendU16(result, (uint16_t)orientation, true);
			appendU16(result, 0); // padding
		}

		// XResolution
		int xresolutionOffset = 0;
		if(xresolution.nominator || xresolution.denominator)
		{
			appendU16(result, (uint16_t)IFDTag::XRESOLUTION, true);
			appendU16(result, (uint16_t)IFDValueType::RATIONAL, true);
			appendU32(result, 1, true); // number of components
			xresolutionOffset = appendU32(result, data.size(), true);
			int offsetInData = appendRational(data, xresolution, true);
			uint32_t* ptr = (uint32_t *)(result.data() + xresolutionOffset);
			*ptr = offsetInData;
		}

		// YResolution
		int yresolutionOffset = 0;
		if(yresolution.nominator || yresolution.denominator)
		{
			appendU16(result, (uint16_t)IFDTag::YRESOLUTION, true);
			appendU16(result, (uint16_t)IFDValueType::RATIONAL, true);
			appendU32(result, 1, true); // number of components
			yresolutionOffset = appendU32(result, data.size(), true);
			int offsetInData = appendRational(data, yresolution, true);
			uint32_t* ptr = (uint32_t *)(result.data() + yresolutionOffset);
			*ptr = offsetInData;
		}

		// Exposure Time
		int exposureTimeOffset = 0;
		if(exposureTime.nominator || exposureTime.denominator)
		{
			appendU16(result, (uint16_t)IFDTag::EXPOSURE_TIME, true);
			appendU16(result, (uint16_t)IFDValueType::RATIONAL, true);
			appendU32(result, 1, true); // number of components
			exposureTimeOffset = appendU32(result, data.size(), true);
			int offsetInData = appendRational(data, exposureTime, true);
			uint32_t* ptr = (uint32_t *)(result.data() + exposureTimeOffset);
			*ptr = offsetInData;
		}

		// ResolutionUnit
		if(resolutionUnit != 0)
		{
			appendU16(result, (uint16_t)IFDTag::RESOLUTION_UNIT, true);
			appendU16(result, (uint16_t)IFDValueType::SHORT, true);
			appendU32(result, 1, true); // number of components
			appendU16(result, resolutionUnit, true);
			appendU16(result, 0); // padding
		}

		// Software Used
		if(softwareUsed != "")
		{
			appendU16(result, (uint16_t)IFDTag::SOFTWARE_USED, true);
			appendU16(result, (uint16_t)IFDValueType::ASCII, true);
			appendU32(result, softwareUsed.size() + 1, true);
			softwareUsedOffset = appendU32(result, data.size() + 1, true);
			int offsetInData = appendVector(data, (char *)softwareUsed.c_str(), softwareUsed.size() + 1);
			uint32_t* ptr = (uint32_t *)(result.data() + softwareUsedOffset);
			*ptr = offsetInData;
		}

		// Date Taken
		// NOTE(vb): For some reason windows file properties doesn't print date taken field!
		// Even though other software does provide this information without a problem
		if(dateTaken != "")
		{
			appendU16(result, (uint16_t)IFDTag::DATE_TAKEN, true);
			appendU16(result, (uint16_t)IFDValueType::ASCII, true);
			appendU32(result, dateTaken.size() + 1, true);
			dateTakenOffset = appendU32(result, data.size() + 1, true);
			int offsetInData = appendVector(data, (char *)dateTaken.c_str(), dateTaken.size() + 1);
			uint32_t* ptr = (uint32_t *)(result.data() + dateTakenOffset);
			*ptr = offsetInData;
		}

		// GPS Info offset
		appendU16(result, (uint16_t) IFDTag::GPS_INFO_OFFSET, true);
		appendU16(result, (uint16_t) IFDValueType::LONG_, true);
		appendU32(result, 1, true); // num components
		gpsInfoOffset = appendU32(result, 0, true); // to be filled

		// next ifd offset
		appendU32(result, 0);

		int resultSize = result.size();
		appendVector(result, data);
		int ifdAndSubdataSize = result.size();

		if(model != "")
		{
			uint32_t *ptr = (uint32_t *) (result.data() + modelOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		if(make != "")
		{
			uint32_t *ptr = (uint32_t *) (result.data() + makeOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		if(xresolutionOffset)
		{
			uint32_t *ptr = (uint32_t *) (result.data() + xresolutionOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		if(yresolutionOffset)
		{
			uint32_t *ptr = (uint32_t *) (result.data() + yresolutionOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		if(exposureTimeOffset)
		{
			uint32_t *ptr = (uint32_t *) (result.data() + exposureTimeOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		if(dateTakenOffset)
		{
			uint32_t *ptr = (uint32_t *) (result.data() + dateTakenOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		if(softwareUsedOffset)
		{
			uint32_t *ptr = (uint32_t *) (result.data() + softwareUsedOffset);
			*ptr += resultSize - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		{
			uint32_t *ptr = (uint32_t *) (result.data() + gpsInfoOffset);
			*ptr = endianSwap((uint32_t)(ifdAndSubdataSize - EXIF_HEADER_SIZE));
		}

		// Writing GPS Info structure
		int numberOfGPSInfoTags = 8;
		appendU16(result, numberOfGPSInfoTags, true);

		// Latitude Ref
		appendU16(result, 1, true);
		appendU16(result, (uint16_t) IFDValueType::ASCII, true);
		appendU32(result, 2, true); // 2 for N/S + \0
		appendU8(result, latitudeRef == LatitudeRef::NORTH ? 'N' : 'S');
		appendU8(result, 0);
		appendU8(result, 0); // padding
		appendU8(result, 0); // padding

		// Latitude
		appendU16(result, 2, true);
		appendU16(result, (uint16_t) IFDValueType::RATIONAL, true);
		appendU32(result, 3, true); // number of components
		int latitudeOffset = appendU32(result, 0); // 0 * sizeof(RationalValue)

		// Longitude Ref
		appendU16(result, 3, true);
		appendU16(result, (uint16_t) IFDValueType::ASCII, true);
		appendU32(result, 2, true); // 2 for E/W + \0
		appendU8(result, longitudeRef == LongitudeRef::EAST ? 'E' : 'W');
		appendU8(result, 0);
		appendU8(result, 0); // padding
		appendU8(result, 0); // padding

		// Longitude
		appendU16(result, 4, true);
		appendU16(result, (uint16_t) IFDValueType::RATIONAL, true);
		appendU32(result, 3, true); // number of components
		int longitudeOffset = appendU32(result, 24); // 3 * sizeof(RationalValue)

		// Altitude Ref
		appendU16(result, 5, true);
		appendU16(result, (uint16_t) IFDValueType::BYTE, true);
		appendU32(result, 1, true); // number of components
		appendU8(result, altitudeIsAboveSeaLevel ? 0 : 1);
		appendU8(result, 0); // padding
		appendU8(result, 0); // padding
		appendU8(result, 0); // padding

		// Altitude
		appendU16(result, 6, true);
		appendU16(result, (uint16_t) IFDValueType::RATIONAL, true);
		appendU32(result, 1, true); // number of components
		int altitudeOffset = appendU32(result, 48); // 6 * sizeof(RationalValue)

		// Track Ref
		appendU16(result, 14, true);
		appendU16(result, (uint16_t) IFDValueType::ASCII, true);
		appendU32(result, 2, true); // 2 for T/M + \0
		appendU8(result, trackRef == GPSTrackRef::TRUE_ ? 'T' : 'M');
		appendU8(result, 0);
		appendU8(result, 0); // padding
		appendU8(result, 0); // padding

		// Track
		appendU16(result, 15, true);
		appendU16(result, (uint16_t) IFDValueType::RATIONAL, true);
		appendU32(result, 1, true); // number of components
		int trackOffset = appendU32(result, 56); // 7 * sizeof(RationalValue)

		//

		int sizeOfResultSoFar = result.size();

		// Latitude
		{
			uint32_t *ptr = (uint32_t *) (result.data() + latitudeOffset);
			*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		// Longitude
		{
			uint32_t *ptr = (uint32_t *) (result.data() + longitudeOffset);
			*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		// Altitude
		{
			uint32_t *ptr = (uint32_t *) (result.data() + altitudeOffset);
			*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		// Track
		{
			uint32_t *ptr = (uint32_t *) (result.data() + trackOffset);
			*ptr += sizeOfResultSoFar - EXIF_HEADER_SIZE;
			*ptr = endianSwap(*ptr);
		}

		//

		appendGPSCoords(result, latitude, true);
		appendGPSCoords(result, longitude, true);

		appendU32(result, altitude, true);
		appendU32(result, 1, true); // denominator for altitude

		int const TRACK_PRECISION = 10000;
		appendU32(result, track * TRACK_PRECISION, true);
		appendU32(result, TRACK_PRECISION, true);

		return result;
	}
}