/*
 * Copyright 2004-2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "RTFTranslator.h"

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

#include <Catalog.h>

#include "ConfigView.h"
#include "convert.h"
#include "RTF.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "RTFTranslator"

#define READ_BUFFER_SIZE 2048
#define DATA_BUFFER_SIZE 64


#define TEXT_IN_QUALITY 0.4
#define TEXT_IN_CAPABILITY 0.6

#define STXT_IN_QUALITY 0.5
#define STXT_IN_CAPABILITY 0.5

#define RTF_OUT_QUALITY RTF_IN_QUALITY
#define RTF_OUT_CAPABILITY RTF_IN_CAPABILITY

// The input formats that this translator supports.
static const translation_format sInputFormats[] = {
        {
                RTF_TEXT_FORMAT,
                B_TRANSLATOR_TEXT,
                RTF_IN_QUALITY,
                RTF_IN_CAPABILITY,
                "text/rtf",
                "RichTextFormat file"
        },
        {
                B_TRANSLATOR_TEXT,
                B_TRANSLATOR_TEXT,
                TEXT_IN_QUALITY,
                TEXT_IN_CAPABILITY,
                "text/plain",
                "Plain text file"
        },
        {
                B_STYLED_TEXT_FORMAT,
                B_TRANSLATOR_TEXT,
                STXT_IN_QUALITY,
                STXT_IN_CAPABILITY,
                "text/x-vnd.Be-stxt",
                "Be styled text file"
        }
};

// The output formats that this translator supports.
static const translation_format sOutputFormats[] = {
        {
                B_TRANSLATOR_TEXT,
                B_TRANSLATOR_TEXT,
                TEXT_OUT_QUALITY,
                TEXT_OUT_CAPABILITY,
                "text/plain",
                "Plain text file"
        },
        {
                B_STYLED_TEXT_FORMAT,
                B_TRANSLATOR_TEXT,
                STXT_OUT_QUALITY,
                STXT_OUT_CAPABILITY,
                "text/x-vnd.Be-stxt",
                "Be styled text file"
        },
        {
                RTF_TEXT_FORMAT,
                B_TRANSLATOR_TEXT,
                RTF_OUT_QUALITY,
                RTF_OUT_CAPABILITY,
                "text/rtf",
                "RichTextFormat file"
        }
};


RTFTranslator::RTFTranslator()
{
        char info[256];
        sprintf(info, B_TRANSLATE("Rich Text Format translator v%d.%d.%d %s"),
                static_cast<int>(B_TRANSLATION_MAJOR_VERSION(RTF_TRANSLATOR_VERSION)),
                static_cast<int>(B_TRANSLATION_MINOR_VERSION(RTF_TRANSLATOR_VERSION)),
                static_cast<int>(B_TRANSLATION_REVISION_VERSION(
                        RTF_TRANSLATOR_VERSION)),
                __DATE__);

        fInfo = strdup(info);
}


RTFTranslator::~RTFTranslator()
{
        free(fInfo);
}


const char *
RTFTranslator::TranslatorName() const
{
        return B_TRANSLATE("RTF text files");
}


const char *
RTFTranslator::TranslatorInfo() const
{
        return B_TRANSLATE("Rich Text Format translator");
}


int32
RTFTranslator::TranslatorVersion() const
{
        return RTF_TRANSLATOR_VERSION;
}


const translation_format *
RTFTranslator::InputFormats(int32 *_outCount) const
{
        if (_outCount == NULL)
                return NULL;

        *_outCount = sizeof(sInputFormats) / sizeof(translation_format);
        return sInputFormats;
}


const translation_format *
RTFTranslator::OutputFormats(int32 *_outCount) const
{
        *_outCount = sizeof(sOutputFormats) / sizeof(translation_format);
        return sOutputFormats;
}


status_t
RTFTranslator::Identify(BPositionIO *stream,
        const translation_format *format, BMessage *ioExtension,
        translator_info *info, uint32 outType)
{
        if (!outType)
                outType = B_TRANSLATOR_TEXT;
        else if (outType != B_TRANSLATOR_TEXT && outType != B_STYLED_TEXT_FORMAT
                && outType != RTF_TEXT_FORMAT)
                return B_NO_TRANSLATOR;


        RTF::Parser parser(*stream);
        status_t status = parser.Identify();

        if (status == B_OK) {
                // Source data is RTF. We can translate to RTF (no-op), plaintext, or
                // styled text.

                // return information about the data in the stream
                info->type = B_TRANSLATOR_TEXT; //RTF_TEXT_FORMAT;
                info->group = B_TRANSLATOR_TEXT;
                info->quality = RTF_IN_QUALITY;
                info->capability = RTF_IN_CAPABILITY;
                strlcpy(info->name, B_TRANSLATE("RichTextFormat file"),
                        sizeof(info->name));
                strcpy(info->MIME, "text/rtf");
        } else {
                // Not an RTF file. We can only work with it if we are translating to
                // RTF.
                if (outType != RTF_TEXT_FORMAT)
                        return B_NO_TRANSLATOR;

                stream->Seek(0, SEEK_SET);
                TranslatorStyledTextStreamHeader header;
                stream->Read(&header, sizeof(header));
                swap_data(B_UINT32_TYPE, &header, sizeof(header),
                        B_SWAP_BENDIAN_TO_HOST);
                stream->Seek(0, SEEK_SET);
                if (header.header.magic == B_STYLED_TEXT_FORMAT
                        && header.header.header_size == (int32)sizeof(header)
                        && header.header.data_size == 0
                        && header.version == 100) {
                        info->type = B_STYLED_TEXT_FORMAT;
                        info->group = B_TRANSLATOR_TEXT;
                        info->quality = STXT_IN_QUALITY;
                        info->capability = STXT_IN_CAPABILITY;
                        strlcpy(info->name, B_TRANSLATE("Be style text file"),
                                sizeof(info->name));
                        strcpy(info->MIME, "text/x-vnd.Be-stxt");
                } else {
                        info->type = B_TRANSLATOR_TEXT;
                        info->group = B_TRANSLATOR_TEXT;
                        info->quality = TEXT_IN_QUALITY;
                        info->capability = TEXT_IN_CAPABILITY;
                        strlcpy(info->name, B_TRANSLATE("Plain text file"),
                                sizeof(info->name));
                        strcpy(info->MIME, "text/plain");
                }
        }
        return B_OK;
}


status_t
RTFTranslator::Translate(BPositionIO *source,
        const translator_info *inInfo, BMessage *ioExtension,
        uint32 outType, BPositionIO *target)
{
        if (target == NULL || source == NULL)
                return B_BAD_VALUE;

        if (!outType)
                outType = B_TRANSLATOR_TEXT;
        if (outType != B_TRANSLATOR_TEXT && outType != B_STYLED_TEXT_FORMAT
                && outType != RTF_TEXT_FORMAT)
                return B_NO_TRANSLATOR;

        if (strncmp(inInfo->MIME, "text/rtf", 8) == 0) {
                RTF::Parser parser(*source);

                RTF::Header header;
                status_t status = parser.Parse(header);
                if (status != B_OK)
                        return status;

                if (outType == B_TRANSLATOR_TEXT)
                        return convert_to_plain_text(header, *target);
                else
                        return convert_to_stxt(header, *target);

        } else if (inInfo->type == B_TRANSLATOR_TEXT) {
                return convert_plain_text_to_rtf(*source, *target);
        } else if (inInfo->type == B_STYLED_TEXT_FORMAT) {
                return convert_styled_text_to_rtf(source, target);
        } else
                return B_BAD_VALUE;

}


status_t
RTFTranslator::MakeConfigurationView(BMessage *ioExtension, BView **_view,
        BRect *_extent)
{
        if (_view == NULL || _extent == NULL)
                return B_BAD_VALUE;

        BView *view = new ConfigView(BRect(0, 0, 225, 175));
        if (view == NULL)
                return BTranslator::MakeConfigurationView(ioExtension, _view, _extent);

        *_view = view;
        *_extent = view->Bounds();
        return B_OK;
}


//      #pragma mark -


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

        return new RTFTranslator();
}