/*
 * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Copyright 2012, Gerasim Troeglazov, 3dEyes@gmail.com. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include "ICNSTranslator.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "ConfigView.h"
#include "ICNSLoader.h"

#include <Catalog.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "ICNSTranslator"

extern "C" {
#include "icns.h"
}

const char *kDocumentCount = "/documentCount";
const char *kDocumentIndex = "/documentIndex";

#define kICNSMimeType "image/icns"
#define kICNSName "Apple Icon"

// The input formats that this translator supports.
static const translation_format sInputFormats[] = {
	{
		ICNS_IMAGE_FORMAT,
		B_TRANSLATOR_BITMAP,
		ICNS_IN_QUALITY,
		ICNS_IN_CAPABILITY,
		kICNSMimeType,
		kICNSName
	},
	{
		B_TRANSLATOR_BITMAP,
		B_TRANSLATOR_BITMAP,
		BITS_IN_QUALITY,
		BITS_IN_CAPABILITY,
		"image/x-be-bitmap",
		"Be Bitmap Format (ICNSTranslator)"
	},
};

// The output formats that this translator supports.
static const translation_format sOutputFormats[] = {
	{
		ICNS_IMAGE_FORMAT,
		B_TRANSLATOR_BITMAP,
		ICNS_OUT_QUALITY,
		ICNS_OUT_CAPABILITY,
		kICNSMimeType,
		kICNSName
	},
	{
		B_TRANSLATOR_BITMAP,
		B_TRANSLATOR_BITMAP,
		BITS_OUT_QUALITY,
		BITS_OUT_CAPABILITY,
		"image/x-be-bitmap",
		"Be Bitmap Format (ICNSTranslator)"
	},
};

// Default settings for the Translator
static const TranSetting sDefaultSettings[] = {
	{B_TRANSLATOR_EXT_HEADER_ONLY, TRAN_SETTING_BOOL, false},
	{B_TRANSLATOR_EXT_DATA_ONLY, TRAN_SETTING_BOOL, false}
};

const uint32 kNumInputFormats = sizeof(sInputFormats)
	/ sizeof(translation_format);
const uint32 kNumOutputFormats = sizeof(sOutputFormats)
	/ sizeof(translation_format);
const uint32 kNumDefaultSettings = sizeof(sDefaultSettings)
	/ sizeof(TranSetting);


ICNSTranslator::ICNSTranslator()
	: BaseTranslator(B_TRANSLATE("Apple icons"), 
		B_TRANSLATE("Apple icon translator"),
		ICNS_TRANSLATOR_VERSION,
		sInputFormats, kNumInputFormats,
		sOutputFormats, kNumOutputFormats,
		"ICNSTranslator",
		sDefaultSettings, kNumDefaultSettings,
		B_TRANSLATOR_BITMAP, ICNS_IMAGE_FORMAT)
{
}


ICNSTranslator::~ICNSTranslator()
{
}


status_t
ICNSTranslator::DerivedIdentify(BPositionIO *stream,
	const translation_format *format, BMessage *ioExtension,
	translator_info *info, uint32 outType)
{
	if (!outType)
		outType = B_TRANSLATOR_BITMAP;
	if (outType != B_TRANSLATOR_BITMAP && outType != ICNS_IMAGE_FORMAT)
		return B_NO_TRANSLATOR;

	uint32 signatureData;
	ssize_t signatureSize = 4;
	if (stream->Read(&signatureData, signatureSize) != signatureSize)
		return B_IO_ERROR;
			
	const uint32 kICNSMagic = B_HOST_TO_BENDIAN_INT32('icns');
	
	if (signatureData != kICNSMagic)
		return B_ILLEGAL_DATA;	
		

	ICNSLoader icnsFile(stream);
	if(!icnsFile.IsLoaded() || icnsFile.IconsCount() <= 0)
		return B_ILLEGAL_DATA;

	int32 documentCount = icnsFile.IconsCount();
	int32 documentIndex = 1;
	
	if (ioExtension) {
		if (ioExtension->FindInt32(DOCUMENT_INDEX, &documentIndex) != B_OK)
			documentIndex = 1;
		if (documentIndex < 1 || documentIndex > documentCount)
			return B_NO_TRANSLATOR;

		ioExtension->RemoveName(DOCUMENT_COUNT);
		ioExtension->AddInt32(DOCUMENT_COUNT, documentCount);
	}	
		
	info->type = ICNS_IMAGE_FORMAT;
	info->group = B_TRANSLATOR_BITMAP;
	info->quality = ICNS_IN_QUALITY;
	info->capability = ICNS_IN_CAPABILITY;
	BString iconName("Apple icon");
	if (documentCount > 1)
		iconName << " #" << documentIndex;
	strlcpy(info->name, iconName.String(), sizeof(info->name));
	strcpy(info->MIME, kICNSMimeType);

	return B_OK;
}


status_t
ICNSTranslator::DerivedTranslate(BPositionIO *source,
	const translator_info *info, BMessage *ioExtension,
	uint32 outType, BPositionIO *target, int32 baseType)
{
	if (!outType)
		outType = B_TRANSLATOR_BITMAP;
	if (outType != B_TRANSLATOR_BITMAP && outType != ICNS_IMAGE_FORMAT)
		return B_NO_TRANSLATOR;

	switch (baseType) {
		case 1:
		{
			TranslatorBitmap bitsHeader;		
			status_t result;		
			result = identify_bits_header(source, NULL, &bitsHeader);
			if (result != B_OK)
				return B_NO_TRANSLATOR;
							
			icns_type_t type = ICNSFormat(bitsHeader.bounds.Width() + 1,
				bitsHeader.bounds.Height() + 1, bitsHeader.colors);				
			if (type == ICNS_NULL_TYPE)
				return B_NO_TRANSLATOR;
			
			if (outType == ICNS_IMAGE_FORMAT) {
				ICNSSaver icnsFile(source, bitsHeader.rowBytes, type);
				if (icnsFile.IsCreated())
					return icnsFile.SaveData(target);
			}
			
			return B_NO_TRANSLATOR;
		}

		case 0:
		{								
			if (outType != B_TRANSLATOR_BITMAP)
				return B_NO_TRANSLATOR;			
							
			ICNSLoader icnsFile(source);
			if (!icnsFile.IsLoaded() || icnsFile.IconsCount() <= 0)
				return B_NO_TRANSLATOR;

			int32 documentIndex = 1;
			
			if (ioExtension) {
				if (ioExtension->FindInt32(DOCUMENT_INDEX, &documentIndex) != B_OK)
					documentIndex = 1;
			}
								
			return icnsFile.GetIcon(target, documentIndex);
		}

		default:
			return B_NO_TRANSLATOR;
	}
}


status_t
ICNSTranslator::DerivedCanHandleImageSize(float width, float height) const
{
	if (ICNSFormat(width, height, B_RGBA32) == ICNS_NULL_TYPE)
		return B_NO_TRANSLATOR;
	return B_OK;
}


BView *
ICNSTranslator::NewConfigView(TranslatorSettings *settings)
{
	return new ConfigView(settings);
}


//	#pragma mark -


BTranslator *
make_nth_translator(int32 n, image_id you, uint32 flags, ...)
{
	if (n != 0)
		return NULL;

	return new ICNSTranslator();
}