/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <TextTable.h>

#include <stdio.h>
#include <ctype.h>
#include <utf8_functions.h>

#include <algorithm>


namespace BPrivate {


// #pragma mark - Column


struct TextTable::Column {
        Column(const BString& title, enum alignment align, bool canTruncate)
                :
                fTitle(title),
                fAlignment(align),
                fCanBeTruncated(canTruncate),
                fNeededWidth(0),
                fWidth(0)
        {
                UpdateNeededWidth(fTitle);
                fMinWidth = fNeededWidth;
        }

        const BString& Title() const
        {
                return fTitle;
        }

        enum alignment Alignment() const
        {
                return fAlignment;
        }

        bool CanBeTruncated() const
        {
                return fCanBeTruncated;
        }

        int32 NeededWidth() const
        {
                return fNeededWidth;
        }

        int32 MinWidth() const
        {
                return fMinWidth;
        }

        int32 Width() const
        {
                return fWidth;
        }

        void SetWidth(int32 width)
        {
                fWidth = width;
        }

        static int32 TextWidth(const BString& text)
        {
                // TODO: Full-width character support.
                int32 textWidth = 0;
                const char* string = text.String(), *stringEnd = text.String() + text.Length();
                while (string < stringEnd) {
                        uint32 charLen = UTF8NextCharLen(string, stringEnd - string);
                        if (charLen == 1 && string[0] == '\033') {
                                // ANSI escape code.
                                charLen++;
                                if (string[charLen - 1] == '[') {
                                        // Keep going until we hit an end character.
                                        while (!isalpha(string[charLen - 1]) && string[charLen - 1] != '\0')
                                                charLen++;
                                }
                        } else {
                                textWidth++;
                        }
                        string += charLen;
                }
                return textWidth;
        }

        void UpdateNeededWidth(const BString& text)
        {
                int32 textWidth = TextWidth(text);
                if (textWidth > fNeededWidth)
                        fNeededWidth = textWidth;
        }

        BString Format(const BString& text)
        {
                int32 textWidth = TextWidth(text);
                if (textWidth == fWidth)
                        return text;

                // truncate, if too long
                if (textWidth > fWidth) {
                        BString result(text);
                        result.TruncateChars(fWidth);
                        return result;
                }

                // align, if too short
                int32 missing = fWidth - textWidth;
                switch (fAlignment) {
                        case B_ALIGN_LEFT:
                        default:
                        {
                                BString result(text);
                                result.Append(' ', missing);
                                return result;
                        }

                        case B_ALIGN_RIGHT:
                        {
                                BString result;
                                result.Append(' ', missing);
                                result.Append(text);
                                return result;
                        }

                        case B_ALIGN_CENTER:
                        {
                                BString result;
                                result.Append(' ', missing / 2);
                                result.Append(text);
                                result.Append(' ', missing - missing / 2);
                                return result;
                        }
                }
        }

private:
        BString                 fTitle;
        enum alignment fAlignment;
        bool                    fCanBeTruncated;
        int32                   fNeededWidth;
        int32                   fMinWidth;
        int32                   fWidth;
};


// #pragma mark - TextTable


TextTable::TextTable()
        :
        fColumns(10),
        fRows(100)
{
}


TextTable::~TextTable()
{
}


int32
TextTable::CountColumns() const
{
        return fColumns.CountItems();
}


void
TextTable::AddColumn(const BString& title, enum alignment align,
        bool canTruncate)
{
        Column* column = new Column(title, align, canTruncate);
        if (!fColumns.AddItem(column)) {
                delete column;
                throw std::bad_alloc();
        }
}


int32
TextTable::CountRows() const
{
        return fRows.CountItems();
}


BString
TextTable::TextAt(int32 rowIndex, int32 columnIndex) const
{
        BStringList* row = fRows.ItemAt(rowIndex);
        if (row == NULL)
                return BString();
        return row->StringAt(columnIndex);
}


void
TextTable::SetTextAt(int32 rowIndex, int32 columnIndex, const BString& text)
{
        // If necessary append empty rows up to the specified row index.
        while (rowIndex >= fRows.CountItems()) {
                BStringList* row = new BStringList();
                if (!fRows.AddItem(row)) {
                        delete row;
                        throw std::bad_alloc();
                }
        }

        // If necessary append empty strings up to the specified column index.
        BStringList* row = fRows.ItemAt(rowIndex);
        while (columnIndex >= row->CountStrings()) {
                if (!row->Add(BString()))
                        throw std::bad_alloc();
        }

        // set the text
        if (!row->Replace(columnIndex, text))
                throw std::bad_alloc();
}


void
TextTable::Print(int32 maxWidth)
{
        int32 columnCount = fColumns.CountItems();
        if (columnCount == 0)
                return;

        // determine the column widths
        int32 rowCount = fRows.CountItems();
        for (int32 rowIndex = 0; rowIndex < rowCount; rowIndex++) {
                BStringList* row = fRows.ItemAt(rowIndex);
                int32 rowColumnCount = std::min(row->CountStrings(), columnCount);
                for (int32 columnIndex = 0; columnIndex < rowColumnCount;
                        columnIndex++) {
                        fColumns.ItemAt(columnIndex)->UpdateNeededWidth(
                                row->StringAt(columnIndex));
                }
        }

        int32 neededWidth = (columnCount - 1) * 2;
                // spacing
        for (int32 i = 0; i < columnCount; i++)
                neededWidth += fColumns.ItemAt(i)->NeededWidth();

        int32 width = neededWidth;
        int32 missingWidth = neededWidth - std::min(maxWidth, neededWidth);

        for (int32 i = 0; i < columnCount; i++) {
                Column* column = fColumns.ItemAt(i);
                if (missingWidth > 0 && column->CanBeTruncated()) {
                        int32 truncateBy = std::min(missingWidth,
                                column->NeededWidth() - column->MinWidth());
                        column->SetWidth(column->NeededWidth() - truncateBy);
                        missingWidth -= truncateBy;
                        width -= truncateBy;
                } else
                        column->SetWidth(column->NeededWidth());
        }

        // print the header
        BString line;
        for (int32 i = 0; i < columnCount; i++) {
                if (i > 0)
                        line << "  ";

                Column* column = fColumns.ItemAt(i);
                line << column->Format(column->Title());
        }
        line << '\n';
        fputs(line.String(), stdout);

        line.SetTo('-', width);
        line << '\n';
        fputs(line.String(), stdout);

        // print the rows
        for (int32 rowIndex = 0; rowIndex < rowCount; rowIndex++) {
                line.Truncate(0);
                BStringList* row = fRows.ItemAt(rowIndex);
                for (int32 columnIndex = 0; columnIndex < columnCount; columnIndex++) {
                        if (columnIndex > 0)
                                line << "  ";

                        line << fColumns.ItemAt(columnIndex)->Format(
                                row->StringAt(columnIndex));
                }

                line << '\n';
                fputs(line.String(), stdout);
        }
}


} // namespace BPrivate