/*
 * Copyright 2013, Stephan Aßmus <superstippi@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include "MarkupParser.h"

#include <new>

#include <math.h>

#include <utf8_functions.h>


MarkupParser::MarkupParser()
        :
        fNormalStyle(),
        fBoldStyle(),
        fItalicStyle(),
        fBoldItalicStyle(),
        fHeadingStyle(),

        fParagraphStyle(),
        fHeadingParagraphStyle(),
        fBulletStyle(),

        fCurrentCharacterStyle(&fNormalStyle),
        fCurrentParagraphStyle(&fParagraphStyle),
        fSpanStartOffset(0)
{
        _InitStyles();
}


MarkupParser::MarkupParser(const CharacterStyle& characterStyle,
        const ParagraphStyle& paragraphStyle)
        :
        fNormalStyle(characterStyle),
        fBoldStyle(),
        fItalicStyle(),
        fBoldItalicStyle(),
        fHeadingStyle(),

        fParagraphStyle(paragraphStyle),
        fHeadingParagraphStyle(),
        fBulletStyle(),

        fCurrentCharacterStyle(&fNormalStyle),
        fCurrentParagraphStyle(&fParagraphStyle),
        fSpanStartOffset(0)
{
        _InitStyles();
}


void
MarkupParser::SetStyles(const CharacterStyle& characterStyle,
        const ParagraphStyle& paragraphStyle)
{
        fNormalStyle = characterStyle;
        fParagraphStyle = paragraphStyle;
        _InitStyles();
}


TextDocumentRef
MarkupParser::CreateDocumentFromMarkup(const BString& text)
{
        TextDocumentRef document(new(std::nothrow) TextDocument(), true);
        if (!document.IsSet())
                return document;

        AppendMarkup(document, text);

        return document;
}


void
MarkupParser::AppendMarkup(const TextDocumentRef& document, const BString& text)
{
        fTextDocument.SetTo(document);

        fCurrentCharacterStyle = &fNormalStyle;
        fCurrentParagraphStyle = &fParagraphStyle;

        fCurrentParagraph = Paragraph(*fCurrentParagraphStyle);
        fSpanStartOffset = 0;

        _ParseText(text);

        fTextDocument.Unset();
}


// #pragma mark - private


void
MarkupParser::_InitStyles()
{
        fBoldStyle = fNormalStyle;
        fBoldStyle.SetBold(true);

        fItalicStyle = fNormalStyle;
        fItalicStyle.SetItalic(true);

        fBoldItalicStyle = fNormalStyle;
        fBoldItalicStyle.SetBold(true);
        fBoldItalicStyle.SetItalic(true);

        float fontSize = fNormalStyle.Font().Size();

        fHeadingStyle = fNormalStyle;
        fHeadingStyle.SetFontSize(ceilf(fontSize * 1.15f));
        fHeadingStyle.SetBold(true);

        fHeadingParagraphStyle = fParagraphStyle;
        fHeadingParagraphStyle.SetSpacingTop(ceilf(fontSize * 0.8f));
        fHeadingParagraphStyle.SetSpacingBottom(ceilf(fontSize * 0.5f));
        fHeadingParagraphStyle.SetJustify(false);

        fBulletStyle = fParagraphStyle;
        fBulletStyle.SetBullet(Bullet("•", fontSize));
        fBulletStyle.SetLineInset(ceilf(fontSize * 0.8f));
}


void
MarkupParser::_ParseText(const BString& text)
{
        int32 start = 0;
        int32 offset = 0;

        int32 charCount = text.CountChars();
        const char* c = text.String();

        while (offset <= charCount) {
                uint32 nextChar = UTF8ToCharCode(&c);

                switch (nextChar) {
// Requires two line-breaks to start a new paragraph, unles the current
// paragraph is already considered a bullet list item. Doesn't work well
// with current set of packages.
//                      case '\n':
//                              _CopySpan(text, start, offset);
//                              if (offset + 1 < charCount && c[0] == '\n') {
//                                      _FinishParagraph();
//                                      offset += 1;
//                                      c += 1;
//                              } else if (fCurrentParagraph.Style() == fBulletStyle) {
//                                      _FinishParagraph();
//                              }
//                              start = offset + 1;
//                              break;

                        case '\n':
                                _CopySpan(text, start, offset);
                                if (offset > 0 && c[-1] != ' ')
                                        _FinishParagraph(offset >= charCount);
                                start = offset + 1;
                                break;

                        case '\0':
                                _CopySpan(text, start, offset);
                                _FinishParagraph(true);
                                start = offset + 1;
                                break;

                        case '\'':
                                if (offset + 2 < charCount && c[0] == '\'') {
                                        int32 tickCount = 2;
                                        if (c[1] == '\'')
                                                tickCount = 3;

                                        // Copy previous span using current style, excluding the
                                        // ticks.
                                        _CopySpan(text, start, offset);

                                        if (tickCount == 2)
                                                _ToggleStyle(fItalicStyle);
                                        else if (tickCount == 3)
                                                _ToggleStyle(fBoldStyle);

                                        // Don't include the ticks in the next span.
                                        offset += tickCount - 1;
                                        start = offset + 1;
                                        c += tickCount - 1;
                                }
                                break;

                        case '=':
                                // Detect headings
                                if (offset == start
                                        && fCurrentParagraph.IsEmpty()
                                        && offset + 2 < charCount
                                        && c[0] == '=' && c[1] == ' ') {

                                        fCurrentParagraph.SetStyle(fHeadingParagraphStyle);
                                        fCurrentCharacterStyle = &fHeadingStyle;

                                        offset += 2;
                                        c += 2;

                                        start = offset + 1;
                                } else if (offset > start
                                        && offset + 2 < charCount
                                        && c[0] == '=' && c[1] == '\n') {

                                        _CopySpan(text, start, offset - 1);

                                        offset += 2;
                                        c += 2;

                                        _FinishParagraph(offset >= charCount);

                                        start = offset + 1;
                                }
                                break;

                        case ' ':
                                // Detect bullets at line starts (preceeding space)
                                if (offset == start
                                        && fCurrentParagraph.IsEmpty()
                                        && offset + 2 < charCount
                                        && (c[0] == '*' || c[0] == '-') && c[1] == ' ') {

                                        fCurrentParagraph.SetStyle(fBulletStyle);

                                        offset += 2;
                                        c += 2;

                                        start = offset + 1;
                                }
                                break;

                        case '*':
                        case '-':
                                // Detect bullets at line starts (no preceeding space)
                                if (offset == start
                                        && fCurrentParagraph.IsEmpty()
                                        && offset + 1 < charCount
                                        && c[0] == ' ') {

                                        fCurrentParagraph.SetStyle(fBulletStyle);

                                        offset += 1;
                                        c += 1;

                                        start = offset + 1;
                                }
                                break;

                        default:
                                break;

                }
                offset++;
        }
}


void
MarkupParser::_CopySpan(const BString& text, int32& start, int32 end)
{
        if (start >= end)
                return;

        BString subString;
        text.CopyCharsInto(subString, start, end - start);
        fCurrentParagraph.Append(TextSpan(subString, *fCurrentCharacterStyle));

        start = end;
}


void
MarkupParser::_ToggleStyle(const CharacterStyle& style)
{
        if (fCurrentCharacterStyle == &style)
                fCurrentCharacterStyle = &fNormalStyle;
        else
                fCurrentCharacterStyle = &style;
}


void
MarkupParser::_FinishParagraph(bool isLast)
{
        if (!isLast)
                fCurrentParagraph.Append(TextSpan("\n", *fCurrentCharacterStyle));

        if (fCurrentParagraph.IsEmpty()) {
                // Append empty span
                fCurrentParagraph.Append(TextSpan("", fNormalStyle));
        }

        fTextDocument->Append(fCurrentParagraph);
        fCurrentParagraph.Clear();
        fCurrentParagraph.SetStyle(fParagraphStyle);
        fCurrentCharacterStyle = &fNormalStyle;
}