/*
 * Copyright 2006-2009, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 */

#include "WonderBrushTranslator.h"

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

#include <Bitmap.h>
#include <Catalog.h>
#include <OS.h>

#include "blending.h"

#include "WonderBrushImage.h"
#include "WonderBrushView.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "WonderBrushTranslator"


using std::nothrow;

// The input formats that this translator supports.
static const translation_format sInputFormats[] = {
        /*{
                B_TRANSLATOR_BITMAP,
                B_TRANSLATOR_BITMAP,
                BBT_IN_QUALITY,
                BBT_IN_CAPABILITY,
                "image/x-be-bitmap",
                "Be Bitmap Format (WonderBrushTranslator)"
        },*/
        {
                WBI_FORMAT,
                B_TRANSLATOR_BITMAP,
                WBI_IN_QUALITY,
                WBI_IN_CAPABILITY,
                "image/x-wonderbrush",
                "WonderBrush image"
        }
};

// The output formats that this translator supports.
static const translation_format sOutputFormats[] = {
        {
                B_TRANSLATOR_BITMAP,
                B_TRANSLATOR_BITMAP,
                BBT_OUT_QUALITY,
                BBT_OUT_CAPABILITY,
                "image/x-be-bitmap",
                "Be Bitmap Format (WonderBrushTranslator)"
        }/*,
        {
                WBI_FORMAT,
                B_TRANSLATOR_BITMAP,
                WBI_OUT_QUALITY,
                WBI_OUT_CAPABILITY,
                "image/x-wonderbrush",
                "WonderBrush image"
        }*/
};


// 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);


BTranslator*
make_nth_translator(int32 n, image_id you, uint32 flags, ...)
{
        if (!n)
                return new WonderBrushTranslator();
        else
                return NULL;
}


WonderBrushTranslator::WonderBrushTranslator()
        : BaseTranslator(B_TRANSLATE("WonderBrush images"), 
                B_TRANSLATE("WonderBrush image translator"),
                WBI_TRANSLATOR_VERSION,
                sInputFormats, kNumInputFormats,
                sOutputFormats, kNumOutputFormats,
                "WBITranslator_Settings",
                sDefaultSettings, kNumDefaultSettings,
                B_TRANSLATOR_BITMAP, WBI_FORMAT)
{
#if GAMMA_BLEND
        init_gamma_blending();
#endif
}


WonderBrushTranslator::~WonderBrushTranslator()
{
#if GAMMA_BLEND
        uninit_gamma_blending();
#endif
}


status_t
identify_wbi_header(BPositionIO* inSource, translator_info* outInfo,
        uint32 outType, WonderBrushImage** _wbImage = NULL)
{
        status_t status = B_NO_MEMORY;
        // construct new WonderBrushImage object and set it to the provided BPositionIO
        WonderBrushImage* wbImage = new(nothrow) WonderBrushImage();
        if (wbImage)
                status = wbImage->SetTo(inSource);

        if (status >= B_OK) {
                if (outInfo) {
                        outInfo->type = WBI_FORMAT;
                        outInfo->group = B_TRANSLATOR_BITMAP;
                        outInfo->quality = WBI_IN_QUALITY;
                        outInfo->capability = WBI_IN_CAPABILITY;
                        strcpy(outInfo->MIME, "image/x-wonderbrush");
                        strlcpy(outInfo->name, B_TRANSLATE("WonderBrush image"),
                                sizeof(outInfo->name));
                }
        } else {
                delete wbImage;
                wbImage = NULL;
        }
        if (!_wbImage) {
                // close WonderBrushImage if caller is not interested in handle
                delete wbImage;
        } else {
                // leave WonderBrushImage open (if it is) and return handle if
                // caller needs it
                *_wbImage = wbImage;
        }

        return status;
}


status_t
WonderBrushTranslator::DerivedIdentify(BPositionIO* inSource,
        const translation_format* inFormat, BMessage* ioExtension,
        translator_info* outInfo, uint32 outType)
{
        return identify_wbi_header(inSource, outInfo, outType);
}


status_t
WonderBrushTranslator::DerivedTranslate(BPositionIO* inSource,
        const translator_info* inInfo, BMessage* ioExtension,
        uint32 outType, BPositionIO* outDestination, int32 baseType)
{
        if (baseType == 0)
                // if inSource is NOT in bits format
                return _TranslateFromWBI(inSource, outType, outDestination);
        else
                // if BaseTranslator did not properly identify the data as
                // bits or not bits
                return B_NO_TRANSLATOR;
}


BView*
WonderBrushTranslator::NewConfigView(TranslatorSettings* settings)
{
        return new WonderBrushView(BRect(0, 0, 225, 175), 
                B_TRANSLATE("WBI Settings"), B_FOLLOW_ALL, B_WILL_DRAW, settings);
}


// #pragma mark -


status_t
WonderBrushTranslator::_TranslateFromWBI(BPositionIO* inSource, uint32 outType,
        BPositionIO* outDestination)
{
        // if copying WBI_FORMAT to WBI_FORMAT
        if (outType == WBI_FORMAT) {
                translate_direct_copy(inSource, outDestination);
                return B_OK;
        }

        WonderBrushImage* wbImage = NULL;
        ssize_t ret = identify_wbi_header(inSource, NULL, outType, &wbImage);
        if (ret < B_OK)
                return ret;

        bool headerOnly = false;
        bool dataOnly = false;

        BBitmap* bitmap = wbImage->Bitmap();
        if (!bitmap)
                return B_ERROR;

        uint32 width = bitmap->Bounds().IntegerWidth() + 1;
        uint32 height = bitmap->Bounds().IntegerHeight() + 1;
        color_space format = bitmap->ColorSpace();
        uint32 bytesPerRow = bitmap->BytesPerRow();

        if (!dataOnly) {
                // Construct and write Be bitmap header
                TranslatorBitmap bitsHeader;
                bitsHeader.magic = B_TRANSLATOR_BITMAP;
                bitsHeader.bounds.left = 0;
                bitsHeader.bounds.top = 0;
                bitsHeader.bounds.right = width - 1;
                bitsHeader.bounds.bottom = height - 1;
                bitsHeader.rowBytes = bytesPerRow;
                bitsHeader.colors = format;
                bitsHeader.dataSize = bitsHeader.rowBytes * height;
                if ((ret = swap_data(B_UINT32_TYPE, &bitsHeader,
                        sizeof(TranslatorBitmap), B_SWAP_HOST_TO_BENDIAN)) < B_OK) {
                        delete bitmap;
                        delete wbImage;
                        return ret;
                } else
                        ret = outDestination->Write(&bitsHeader, sizeof(TranslatorBitmap));
        }

        if (ret >= B_OK && !headerOnly) {
                // read one row at a time and write out the results
                uint8* row = (uint8*)bitmap->Bits();
                for (uint32 y = 0; y < height && ret >= B_OK; y++) {
                        ret = outDestination->Write(row, bytesPerRow);
                        row += bytesPerRow;
                }

        }

        delete bitmap;
        delete wbImage;

        if (ret >= B_OK)
                ret = B_OK;

        return (status_t)ret;
}