/*****************************************************************************/
// stxtinfo
// Written by Michael Wilber, Haiku Translation Kit Team
//
// Version:
//
// stxtinfo is a command line program for displaying text information about
// Be styled text (the format that StyledEdit uses).  StyledEdit stores the
// styled text information as an attribute of the file and it is this 
// information that this program is concerned with.  This format is outlined
// in TranslatorFormats.h.
//
// This program prints out information from the "styles" attribute that
// StyledEdit uses.  If that information is not available, it attempts
// to read the styles information from the contents of the file, assuming
// that it is the format that BTranslationUtils::PutStyledText() writes
// out.
//
// The intention of this program is to aid with the development and 
// debugging of the STXTTranslator.  It may also be useful for debugging /
// testing StyledEdit. 
//
// This application and all source files used in its construction, except 
// where noted, are licensed under the MIT License, and have been written 
// and are:
//
// Copyright (c) 2003 Haiku Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
// and/or sell copies of the Software, and to permit persons to whom the 
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included 
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ByteOrder.h>
#include <File.h>
#include <TranslatorFormats.h>
#include <Font.h>
        // for B_UNICODE_UTF8
#include <fs_attr.h>
        // for attr_info

#define max(x,y) ((x > y) ? x : y)
#define DATA_BUFFER_SIZE 64

struct StylesHeader {
        uint32 magic;   // 41 6c 69 21
        uint32 version; // 0
        int32 count;
};

struct Style {
        int32   offset;
        char    family[64];
        char    style[64];
        float   size;
        float   shear;  // typically 90.0
        uint16  face;   // typically 0
        uint8   red;
        uint8   green;
        uint8   blue;
        uint8   alpha;  // 255 == opaque
        uint16  reserved; // 0
};

void
PrintStyle(Style &style, int32 i)
{
        style.offset = B_BENDIAN_TO_HOST_INT32(style.offset);
        style.size = B_BENDIAN_TO_HOST_FLOAT(style.size);
        style.shear = B_BENDIAN_TO_HOST_FLOAT(style.shear);
        style.face = B_BENDIAN_TO_HOST_INT16(style.face);
        style.reserved = B_BENDIAN_TO_HOST_INT16(style.reserved);                       
                        
        printf("\nStyle %d:\n", static_cast<int>(i + 1));
        printf("offset: %d\n", static_cast<int>(style.offset));
        printf("family: %s\n", style.family);
        printf("style: %s\n", style.style);
        printf("size: %f\n", style.size);
        printf("shear: %f (typically 90.0)\n", style.shear);
        printf("face: %u (typically 0)\n",
                static_cast<unsigned int>(style.face));
        printf("RGBA: (%u, %u, %u, %u)\n",
                static_cast<unsigned int>(style.red),
                static_cast<unsigned int>(style.blue),
                static_cast<unsigned int>(style.green),
                static_cast<unsigned int>(style.alpha));
                printf("reserved: %u (should be 0)\n",
                static_cast<unsigned int>(style.reserved));
}

bool
PrintStylesAttribute(BFile &file)
{
        const char *kAttrName = "styles";
        attr_info info;
        
        if (file.GetAttrInfo(kAttrName, &info) != B_OK)
                return false;
        if (info.type != B_RAW_TYPE) {
                printf("Error: styles attribute is of the wrong type\n");
                return false;
        }
        if (info.size < 160) {
                printf("Error: styles attribute is missing information\n");
                return false;
        }

        uint8 *pflatRunArray = new uint8[info.size];
        if (!pflatRunArray) {
                printf("Error: Not enough memory available to read styles attribute\n");
                return false;
        }
        
        ssize_t amtread = file.ReadAttr(kAttrName, B_RAW_TYPE, 0,
                pflatRunArray, info.size);
        if (amtread != info.size) {
                printf("Error: Unable to read styles attribute\n");
                return false;
        }
                                
        // Check Styles
        StylesHeader stylesheader;
        memcpy(&stylesheader, pflatRunArray, sizeof(StylesHeader));
        if (swap_data(B_UINT32_TYPE, &stylesheader, sizeof(StylesHeader),
                B_SWAP_BENDIAN_TO_HOST) != B_OK) {
                printf("Error: Unable to swap byte order of styles header\n");
                return false;
        }
                
        // Print StylesHeader info
        printf("\"styles\" attribute data:\n\n");
        
        printf("magic number: 0x%.8lx ",
                static_cast<unsigned long>(stylesheader.magic));
        if (stylesheader.magic == 'Ali!')
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n",
                        static_cast<unsigned long>('Ali!'));
                
        printf("version: 0x%.8lx ",
                static_cast<unsigned long>(stylesheader.version));
        if (stylesheader.version == 0)
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n", 0UL);
                        
        printf("number of styles: %d\n",
                static_cast<int>(stylesheader.count));
                
        // Check and Print out each style
        Style *pstyle = reinterpret_cast<Style *>(pflatRunArray + sizeof(StylesHeader));
        for (int32 i = 0; i < stylesheader.count; i++)
                PrintStyle(*(pstyle + i), i);
                                
        delete[] pflatRunArray;
        pflatRunArray = NULL;
        
        return true;
}

bool
PrintStxtInfo(BFile &file)
{
        const uint32 kstxtsize = sizeof(TranslatorStyledTextStreamHeader);
        const uint32 ktxtsize = sizeof(TranslatorStyledTextTextHeader);
        const uint32 kstylsize = sizeof(TranslatorStyledTextStyleHeader);
        const uint32 kStyleSize = sizeof(Style);
                
        uint8 buffer[max(max(max(kstxtsize, ktxtsize), kstylsize), kStyleSize)];
                
        // Check STXT Header
        status_t nread = 0;
        nread = file.Read(buffer, kstxtsize);
        if (nread != static_cast<status_t>(kstxtsize)) {
                printf("Error: Unable to read stream header\n");
                return false;
        }
        TranslatorStyledTextStreamHeader stxtheader;
        memcpy(&stxtheader, buffer, kstxtsize);
        if (swap_data(B_UINT32_TYPE, &stxtheader, kstxtsize,
                B_SWAP_BENDIAN_TO_HOST) != B_OK) {
                printf("Error: Unable to swap byte order of stream header\n");
                return false;
        }
        
        if (stxtheader.header.magic != B_STYLED_TEXT_FORMAT) {
                printf("Styled text magic number is incorrect, aborting.\n");
                return false;
        }
                
        // Print Stream Header (STXT)
        printf("Stream Header (STXT section):\n\n");
                
        printf("magic number: 0x%.8lx ", stxtheader.header.magic);
        if (stxtheader.header.magic == B_STYLED_TEXT_FORMAT)
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n",
                        static_cast<unsigned long>(B_STYLED_TEXT_FORMAT));
                                
        printf("header size: %u ",
                static_cast<unsigned int>(stxtheader.header.header_size));
        if (stxtheader.header.header_size == kstxtsize)
                printf("(valid)\n");
        else
                printf("(INVALID, should be %u)\n",
                        static_cast<unsigned int>(kstxtsize));
                                
        printf("data size: %u ",
                static_cast<unsigned int>(stxtheader.header.data_size));
        if (stxtheader.header.data_size == 0)
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0)\n");
                        
        printf("version: %d ",
                static_cast<int>(stxtheader.version));
        if (stxtheader.version == 100)
                printf("(valid)\n");
                else
                printf("(INVALID, should be 100)\n");

        
        // Check the TEXT header
        TranslatorStyledTextTextHeader txtheader;
        if (file.Read(buffer, ktxtsize) != static_cast<ssize_t>(ktxtsize)) {
                printf("Error: Unable to read text header\n");
                return false;
        }
        memcpy(&txtheader, buffer, ktxtsize);
        if (swap_data(B_UINT32_TYPE, &txtheader, ktxtsize,
                B_SWAP_BENDIAN_TO_HOST) != B_OK) {
                printf("Error: Unable to swap byte order of text header\n");
                return false;
        }
                        
        // Print Text Header (TEXT)
        printf("\nText Header (TEXT section):\n\n");
                
        printf("magic number: 0x%.8lx ", txtheader.header.magic);
        if (txtheader.header.magic == 'TEXT')
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n",
                        static_cast<unsigned long>('TEXT'));
                                
        printf("header size: %u ",
                static_cast<unsigned int>(txtheader.header.header_size));
        if (stxtheader.header.header_size == ktxtsize)
                printf("(valid)\n");
        else
                printf("(INVALID, should be %u)\n",
                        static_cast<unsigned int>(ktxtsize));
                                
        printf("data size (bytes of text): %u\n",
                static_cast<unsigned int>(txtheader.header.data_size));
                        
        printf("character set: %d ",
                static_cast<int>(txtheader.charset));
        if (txtheader.charset == B_UNICODE_UTF8)
                printf("(valid)\n");
        else
                printf("(INVALID, should be %d)\n", B_UNICODE_UTF8);
                        
        // Skip the text data
        off_t seekresult, pos;
        pos = stxtheader.header.header_size +
                txtheader.header.header_size +
                txtheader.header.data_size;
        seekresult = file.Seek(txtheader.header.data_size, SEEK_CUR);
        if (seekresult < pos) {
                printf("Error: Unable to seek past text data. " \
                        "Text data could be missing\n");
                return false;
        }
        if (seekresult > pos) {
                printf("Error: File position is beyond expected value\n");
                return false;
        }

        // Check the STYL header (not all STXT files have this)
        ssize_t read = 0;
        TranslatorStyledTextStyleHeader stylheader;
        read = file.Read(buffer, kstylsize);
        if (read != static_cast<ssize_t>(kstylsize) && read != 0) {
                printf("Error: Unable to read entire style header\n");
                return false;
        }
        
        // If there is no STYL header (and no errors)
        if (read != static_cast<ssize_t>(kstylsize)) {
                printf("\nFile contains no Style Header (STYL section)\n");
                return false;
        }
                        
        memcpy(&stylheader, buffer, kstylsize);
        if (swap_data(B_UINT32_TYPE, &stylheader, kstylsize,
                B_SWAP_BENDIAN_TO_HOST) != B_OK) {
                printf("Error: Unable to swap byte order of style header\n");
                return false;
        }
                
        // Print Style Header (STYL)
        printf("\nStyle Header (STYL section):\n\n");
        
        printf("magic number: 0x%.8lx ", stylheader.header.magic);
        if (stylheader.header.magic == 'STYL')
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n",
                        static_cast<unsigned long>('STYL'));
                                
        printf("header size: %u ",
                static_cast<unsigned int>(stylheader.header.header_size));
        if (stylheader.header.header_size == kstylsize)
                printf("(valid)\n");
        else
                printf("(INVALID, should be %u)\n",
                        static_cast<unsigned int>(kstylsize));
                                
        printf("data size: %u\n",
                static_cast<unsigned int>(stylheader.header.data_size));
        printf("apply offset: %u (usually 0)\n",
                static_cast<unsigned int>(stylheader.apply_offset));
        printf("apply length: %u (usually the text data size)\n",
                static_cast<unsigned int>(stylheader.apply_length));
                        
        // Check Styles
        StylesHeader stylesheader;
        read = file.Read(buffer, sizeof(StylesHeader));
        if (read != sizeof(StylesHeader)) {
                printf("Error: Unable to read Styles header\n");
                return false;
        }
        memcpy(&stylesheader, buffer, sizeof(StylesHeader));
        if (swap_data(B_UINT32_TYPE, &stylesheader, sizeof(StylesHeader),
                B_SWAP_BENDIAN_TO_HOST) != B_OK) {
                printf("Error: Unable to swap byte order of styles header\n");
                return false;
        }
                
        // Print StylesHeader info
        printf("\nStyles Header (Ali! section):\n\n");
        
        printf("magic number: 0x%.8lx ",
                static_cast<unsigned long>(stylesheader.magic));
        if (stylesheader.magic == 'Ali!')
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n",
                        static_cast<unsigned long>('Ali!'));
                
        printf("version: 0x%.8lx ",
                static_cast<unsigned long>(stylesheader.version));
        if (stylesheader.version == 0)
                printf("(valid)\n");
        else
                printf("(INVALID, should be 0x%.8lx)\n", 0UL);
                        
        printf("number of styles: %d\n",
                static_cast<int>(stylesheader.count));
                
        // Check and Print out each style
        for (int32 i = 0; i < stylesheader.count; i++) {
                Style style;
                read = file.Read(&style, sizeof(Style));
                if (read != sizeof(Style)) {
                        printf("Error: Unable to read style %d\n",
                                static_cast<int>(i + 1));
                        return false;
                }                       
                        
                PrintStyle(style, i);
        }
        
        return true;
}

int
main(int argc, char **argv)
{
        printf("\n");
        
        if (argc == 2) {
                BFile file(argv[1], B_READ_ONLY);
                if (file.InitCheck() != B_OK)
                        printf("Error opening %s\n", argv[1]);
                else {
                        printf("Be styled text information for: %s\n\n", argv[1]);
                        if (PrintStylesAttribute(file) == false) {
                                printf("Unable to read styles attribute, attempting to read " \
                                        "style information from file...\n\n");
                                PrintStxtInfo(file);
                        }
                }
        }
        else {
                printf("stxtinfo - reports information about a Be styled text file\n");
                printf("\nUsage:\n");
                printf("stxtinfo filename.stxt\n");     
        }
        
        printf("\n");

        return 0;
}