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

#include "TextEditor.h"

#include <algorithm>
#include <stdio.h>


TextEditor::TextEditor()
        :
        fDocument(),
        fLayout(),
        fSelection(),
        fCaretAnchorX(0.0f),
        fStyleAtCaret(),
        fEditingEnabled(true)
{
}


TextEditor::TextEditor(const TextEditor& other)
        :
        fDocument(other.fDocument),
        fLayout(other.fLayout),
        fSelection(other.fSelection),
        fCaretAnchorX(other.fCaretAnchorX),
        fStyleAtCaret(other.fStyleAtCaret),
        fEditingEnabled(other.fEditingEnabled)
{
}


TextEditor::~TextEditor()
{
}


TextEditor&
TextEditor::operator=(const TextEditor& other)
{
        if (this == &other)
                return *this;

        fDocument = other.fDocument;
        fLayout = other.fLayout;
        fSelection = other.fSelection;
        fCaretAnchorX = other.fCaretAnchorX;
        fStyleAtCaret = other.fStyleAtCaret;
        fEditingEnabled = other.fEditingEnabled;
        return *this;
}


bool
TextEditor::operator==(const TextEditor& other) const
{
        if (this == &other)
                return true;

        return fDocument == other.fDocument
                && fLayout == other.fLayout
                && fSelection == other.fSelection
                && fCaretAnchorX == other.fCaretAnchorX
                && fStyleAtCaret == other.fStyleAtCaret
                && fEditingEnabled == other.fEditingEnabled;
}


bool
TextEditor::operator!=(const TextEditor& other) const
{
        return !(*this == other);
}


// #pragma mark -


void
TextEditor::SetDocument(const TextDocumentRef& ref)
{
        fDocument = ref;
        SetSelection(TextSelection());
}


void
TextEditor::SetLayout(const TextDocumentLayoutRef& ref)
{
        fLayout = ref;
        SetSelection(TextSelection());
}


void
TextEditor::SetEditingEnabled(bool enabled)
{
        fEditingEnabled = enabled;
}


void
TextEditor::SetCaret(BPoint location, bool extendSelection)
{
        if (!fDocument.IsSet() || !fLayout.IsSet())
                return;

        bool rightOfChar = false;
        int32 caretOffset = fLayout->TextOffsetAt(location.x, location.y,
                rightOfChar);

        if (rightOfChar)
                caretOffset++;

        _SetCaretOffset(caretOffset, true, extendSelection, true);
}


void
TextEditor::SelectAll()
{
        if (!fDocument.IsSet())
                return;

        SetSelection(TextSelection(0, fDocument->Length()));
}


void
TextEditor::SetSelection(TextSelection selection)
{
        _SetSelection(selection.Caret(), selection.Anchor(), true, true);
}


void
TextEditor::SetCharacterStyle(::CharacterStyle style)
{
        if (fStyleAtCaret == style)
                return;

        fStyleAtCaret = style;

        if (HasSelection()) {
                // TODO: Apply style to selection range
        }
}


void
TextEditor::KeyDown(KeyEvent event)
{
        if (!fDocument.IsSet())
                return;

        bool select = (event.modifiers & B_SHIFT_KEY) != 0;

        switch (event.key) {
                case B_UP_ARROW:
                        LineUp(select);
                        break;

                case B_DOWN_ARROW:
                        LineDown(select);
                        break;

                case B_LEFT_ARROW:
                        if (HasSelection() && !select) {
                                _SetCaretOffset(
                                        std::min(fSelection.Caret(), fSelection.Anchor()),
                                        true, false, true);
                        } else
                                _SetCaretOffset(fSelection.Caret() - 1, true, select, true);
                        break;

                case B_RIGHT_ARROW:
                        if (HasSelection() && !select) {
                                _SetCaretOffset(
                                        std::max(fSelection.Caret(), fSelection.Anchor()),
                                        true, false, true);
                        } else
                                _SetCaretOffset(fSelection.Caret() + 1, true, select, true);
                        break;

                case B_HOME:
                        LineStart(select);
                        break;

                case B_END:
                        LineEnd(select);
                        break;

                case B_ENTER:
                        Insert(fSelection.Caret(), "\n");
                        break;

                case B_TAB:
                        // TODO: Tab support in TextLayout
                        Insert(fSelection.Caret(), " ");
                        break;

                case B_ESCAPE:
                        break;

                case B_BACKSPACE:
                        if (HasSelection()) {
                                Remove(SelectionStart(), SelectionLength());
                        } else {
                                if (fSelection.Caret() > 0)
                                        Remove(fSelection.Caret() - 1, 1);
                        }
                        break;

                case B_DELETE:
                        if (HasSelection()) {
                                Remove(SelectionStart(), SelectionLength());
                        } else {
                                if (fSelection.Caret() < fDocument->Length())
                                        Remove(fSelection.Caret(), 1);
                        }
                        break;

                case B_INSERT:
                        // TODO: Toggle insert mode (or maybe just don't support it)
                        break;

                case B_PAGE_UP:
                case B_PAGE_DOWN:
                case B_SUBSTITUTE:
                case B_FUNCTION_KEY:
                case B_KATAKANA_HIRAGANA:
                case B_HANKAKU_ZENKAKU:
                        break;

                default:
                        if (event.bytes != NULL && event.length > 0) {
                                // Handle null-termintating the string
                                BString text(event.bytes, event.length);

                                Replace(SelectionStart(), SelectionLength(), text);
                        }
                        break;
        }
}


status_t
TextEditor::Insert(int32 offset, const BString& string)
{
        if (!fEditingEnabled || !fDocument.IsSet())
                return B_ERROR;

        status_t ret = fDocument->Insert(offset, string, fStyleAtCaret);

        if (ret == B_OK) {
                _SetCaretOffset(offset + string.CountChars(), true, false, true);
        }

        return ret;
}


status_t
TextEditor::Remove(int32 offset, int32 length)
{
        if (!fEditingEnabled || !fDocument.IsSet())
                return B_ERROR;

        status_t ret = fDocument->Remove(offset, length);

        if (ret == B_OK) {
                _SetCaretOffset(offset, true, false, true);
        }

        return ret;
}


status_t
TextEditor::Replace(int32 offset, int32 length, const BString& string)
{
        if (!fEditingEnabled || !fDocument.IsSet())
                return B_ERROR;

        status_t ret = fDocument->Replace(offset, length, string);

        if (ret == B_OK) {
                _SetCaretOffset(offset + string.CountChars(), true, false, true);
        }

        return ret;
}


// #pragma mark -


void
TextEditor::LineUp(bool select)
{
        if (!fLayout.IsSet())
                return;

        int32 lineIndex = fLayout->LineIndexForOffset(fSelection.Caret());
        _MoveToLine(lineIndex - 1, select);
}


void
TextEditor::LineDown(bool select)
{
        if (!fLayout.IsSet())
                return;

        int32 lineIndex = fLayout->LineIndexForOffset(fSelection.Caret());
        _MoveToLine(lineIndex + 1, select);
}


void
TextEditor::LineStart(bool select)
{
        if (!fLayout.IsSet())
                return;

        int32 lineIndex = fLayout->LineIndexForOffset(fSelection.Caret());
        _SetCaretOffset(fLayout->FirstOffsetOnLine(lineIndex), true, select,
                true);
}


void
TextEditor::LineEnd(bool select)
{
        if (!fLayout.IsSet())
                return;

        int32 lineIndex = fLayout->LineIndexForOffset(fSelection.Caret());
        _SetCaretOffset(fLayout->LastOffsetOnLine(lineIndex), true, select,
                true);
}


// #pragma mark -


bool
TextEditor::HasSelection() const
{
        return SelectionLength() > 0;
}


int32
TextEditor::SelectionStart() const
{
        return std::min(fSelection.Caret(), fSelection.Anchor());
}


int32
TextEditor::SelectionEnd() const
{
        return std::max(fSelection.Caret(), fSelection.Anchor());
}


int32
TextEditor::SelectionLength() const
{
        return SelectionEnd() - SelectionStart();
}


// #pragma mark - private


// _MoveToLine
void
TextEditor::_MoveToLine(int32 lineIndex, bool select)
{
        if (lineIndex < 0) {
                // Move to beginning of line instead. Most editors do. Some only when
                // selecting. Note that we are not updating the horizontal anchor here,
                // even though the horizontal caret position changes. Most editors
                // return to the previous horizonal offset when moving back down from
                // the beginning of the line.
                _SetCaretOffset(0, false, select, true);
                return;
        }
        if (lineIndex >= fLayout->CountLines()) {
                // Move to end of line instead, see above for why we do not update the
                // horizontal anchor.
                _SetCaretOffset(fDocument->Length(), false, select, true);
                return;
        }

        float x1;
        float y1;
        float x2;
        float y2;
        fLayout->GetLineBounds(lineIndex , x1, y1, x2, y2);

        bool rightOfCenter;
        int32 textOffset = fLayout->TextOffsetAt(fCaretAnchorX, (y1 + y2) / 2,
                rightOfCenter);

        if (rightOfCenter)
                textOffset++;

        _SetCaretOffset(textOffset, false, select, true);
}

void
TextEditor::_SetCaretOffset(int32 offset, bool updateAnchor,
        bool lockSelectionAnchor, bool updateSelectionStyle)
{
        if (!fDocument.IsSet())
                return;

        if (offset < 0)
                offset = 0;
        int32 textLength = fDocument->Length();
        if (offset > textLength)
                offset = textLength;

        int32 caret = offset;
        int32 anchor = lockSelectionAnchor ? fSelection.Anchor() : offset;
        _SetSelection(caret, anchor, updateAnchor, updateSelectionStyle);
}


void
TextEditor::_SetSelection(int32 caret, int32 anchor, bool updateAnchor,
        bool updateSelectionStyle)
{
        if (!fLayout.IsSet())
                return;

        if (caret == fSelection.Caret() && anchor == fSelection.Anchor())
                return;

        fSelection.SetCaret(caret);
        fSelection.SetAnchor(anchor);

        if (updateAnchor) {
                float x1;
                float y1;
                float x2;
                float y2;

                fLayout->GetTextBounds(caret, x1, y1, x2, y2);
                fCaretAnchorX = x1;
        }

        if (updateSelectionStyle)
                _UpdateStyleAtCaret();
}


void
TextEditor::_UpdateStyleAtCaret()
{
        if (!fDocument.IsSet())
                return;

        int32 offset = fSelection.Caret() - 1;
        if (offset < 0)
                offset = 0;
        SetCharacterStyle(fDocument->CharacterStyleAt(offset));
}