/*! \file SimpleConsole.cpp
 * \brief implementation of SimpleConsole
 * \author "Melven Zoellner" <melven@topen.org>
 *
*/
#include "SimpleConsole.h"

#include <QScrollBar>
#include <QTextBlock>
#include <QKeyEvent>
#include <QCompleter>
#include <QAbstractItemView>
#include <QStringListModel>
#include <QMenu>
#include <QEventLoop>

#include <QDebug>
#include <QClipboard>
#include <QApplication>


SimpleConsole::SimpleConsole(QWidget *parent) :
    QPlainTextEdit(parent)
{
    _prompt  = "py > ";
    _prompt2 = "...";
    _inputIndex = 0;

    _historyPosition = 0;

    _completer = NULL;

    _state = UndefinedConsoleState;
    _userInputEventLoop = new QEventLoop(this);

    setUndoRedoEnabled(false);

    // set up font and cursor
    QFont font;
    font.setStyleHint(QFont::Monospace);
    font.setFamily("Monospace");
    font.setPointSize(font.pointSize());
    setFont(font);

    connect(this, SIGNAL(cursorPositionChanged()),
            this, SLOT(updateLastValidCursor()));

    // resize so it is not as small
    //resize(500,200);
}


void SimpleConsole::keyPressEvent(QKeyEvent *event)
{
    // don't handle any input if not in user input state
    if( !(_state == ShowCommandPrompt || _state == WaitingForUserInput) )
        return;

    bool handled = true;


    bool completing = (
                state() == ShowCommandPrompt &&
                _completer != NULL &&
            _completer->popup()->isVisible() );


    if( completing )
    {
        // let the completer handle some stuff
        if( event->key() == Qt::Key_Enter   ||
                event->key() == Qt::Key_Return  ||
                event->key() == Qt::Key_Escape  ||
                event->key() == Qt::Key_Tab     ||
                event->key() == Qt::Key_Backtab )
        {
            event->ignore();
            return;
        }


        // check if we need to hide the completer...
        int notCtrlOrShift = ~(Qt::ControlModifier | Qt::ShiftModifier | Qt::NoModifier);
        QString c = event->text();
        bool beginNewWord = !(c.isEmpty() || (c.length() == 1 && ( c[0].isLetterOrNumber() || c == "_" )) );
        if( event->modifiers() & notCtrlOrShift     ||
                beginNewWord                            )
        {
            _completer->popup()->hide();
            completing = false;
        }

    }


    // check if cursor is invalid, then reset it to a valid cursor
        QTextCursor cursor = textCursor();
    //    if( !modificationAllowed(cursor) )
    //    {
    //        setTextCursor(_lastValidCursor);
    //        setReadOnly(false);
    //        cursor = textCursor();
    //    }

    if( (!completing) && event->matches(QKeySequence::InsertLineSeparator) )
    {
        // command over multiple lines
        if( _state == ShowCommandPrompt )
            extendMultilineCommand();
        else // _state == WaitingForUserInput
            _userInputEventLoop->exit();
    }

    else if( (!completing) && event->matches(QKeySequence::InsertParagraphSeparator) )
    {
        // on return emit signal to execute line
        if( _state == ShowCommandPrompt )
            executeCurrentCommand();
        else // _state == WaitingForUserInput
            _userInputEventLoop->exit();
    }

    // look up in history
    else if( event->matches(QKeySequence::MoveToPreviousLine) &&
             _state == ShowCommandPrompt && (!completing) )
        historyUp();

    // look down in history
    else if( event->matches(QKeySequence::MoveToNextLine) &&
             _state == ShowCommandPrompt && (!completing) )
        historyDown();

    // backspace: delete previous character
    else if( event->key() == Qt::Key_Backspace &&
             (event->modifiers() == Qt::NoModifier ||
              event->modifiers() == Qt::ShiftModifier) )
    {
        // create cursor to test if allowed
        if( !cursor.hasSelection() )
            cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor);

        if( modificationAllowed(cursor) )
            QPlainTextEdit::keyPressEvent(event);
    }

    // delete character
    else if( event->matches(QKeySequence::Delete) )
    {
        // create cursor to test if allowed
        if( !cursor.hasSelection() )
            cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);

        if( modificationAllowed(cursor) )
            QPlainTextEdit::keyPressEvent(event);
    }

    // delete several characters at once
    else if( event->matches(QKeySequence::DeleteEndOfWord) ||
             event->matches(QKeySequence::DeleteEndOfLine) ||
             event->matches(QKeySequence::DeleteStartOfWord) )
    {
        if( event->matches(QKeySequence::DeleteStartOfWord) )
            cursor.movePosition(QTextCursor::StartOfWord, QTextCursor::KeepAnchor);

        if( modificationAllowed(cursor) )
            QPlainTextEdit::keyPressEvent(event);
    }

    // autocomplete
    else if( event->key() == Qt::Key_Tab &&
             event->modifiers() == Qt::NoModifier &&
             _state == ShowCommandPrompt )
    {
        emit autocompletionRequested();
        requestAutocompletion();
    }
    else if( event->matches(QKeySequence::Copy))
    {
        copy();
    }
    else if( event->matches(QKeySequence::Paste))
    {
        QStringList lines= qApp->clipboard()->text().split("\n");
        for(int i=0;i<lines.count();i++)
        {
            insertPrompt(false);
            this->insertPlainText(lines.at(i));
            historyAdd(currentLine());
        }
    }
    else if( event->matches(QKeySequence::Cut))
    {
        cut();
    }
    // only send pure text to parent
    else if( event->text().length() == 1 && event->text()[0].isPrint() )
    {
        if( !modificationAllowed(cursor) )
        {
            setTextCursor(_lastValidCursor);
            setReadOnly(false);
            cursor = textCursor();
        }
        QPlainTextEdit::keyPressEvent(event);
    }
    else
    {
        // at last check if the user wants some cursor movement
        handled = positionCursor(event);

        // special case for completion:
        // close completer popup if we moved for more than a word
        if( handled && completing )
        {
            bool movedOutsideOfWord = false;
            cursor.movePosition(QTextCursor::StartOfWord);
            if( textCursor() < cursor )
                movedOutsideOfWord = true;
            cursor.movePosition(QTextCursor::EndOfWord);
            if( textCursor() > cursor )
                movedOutsideOfWord = true;

            if( movedOutsideOfWord )
            {
                _completer->popup()->hide();
                completing = false;
            }

        }
    }


    // if we handled the event, scroll there
    if( handled )
        ensureCursorVisible();

    // if still completing, update completer
    if( completing )
        requestAutocompletion();

    // mark the event as handled
    event->setAccepted(handled);
}


void SimpleConsole::contextMenuEvent(QContextMenuEvent *event)
{
    // create a new context menu
    QMenu *menu = new QMenu(this);


    QTextCursor cursor = textCursor();
    if( modificationAllowed(cursor) )
    {
        // cut, copy and paste
        menu->addAction(tr("Cut"), this, SLOT(cut()));
        menu->addAction(tr("Copy"),this, SLOT(copy()));
        menu->addAction(tr("Paste"), this, SLOT(paste()));
    }
    else
    {
        // only copy if in readonly part
        menu->addAction(tr("Copy"),this, SLOT(copy()));
    }

    // show the menu
    menu->exec(event->globalPos());

    // we can delete it now
    delete menu;
}


void SimpleConsole::setCompleter(QCompleter *c)
{
    // disconnect all old connections
    if( _completer )
        disconnect(_completer, 0, this, 0);

    _completer = c;

    // setup the completer
    if( _completer )
    {
        _completer->setWidget(this);
        _completer->setCompletionMode(QCompleter::PopupCompletion);
        connect(_completer, SIGNAL(activated(QString)),
                this,       SLOT(insertCompletion(QString)));
    }
}

/* TODO AJE: fix multilines commands */
void SimpleConsole::insertPrompt(bool newBlock)
{
    if( !setState(ShowCommandPrompt) )
        return;

    if( newBlock )
    {
        // a bit of intelligence here, reuse existing block if it is empty, prevents unncecessary new lines
        if( textCursor().block().text().length() != 0 )
            textCursor().insertBlock();
        //textCursor().beginEditBlock();
        textCursor().insertText(_prompt);
        _inputIndex = _prompt.length();
        _lastValidCursor = textCursor();
    }
    else
    {
        //textCursor().beginEditBlock();
        textCursor().insertHtml("<br>"+_prompt2);
        //textCursor().insertText("\n");
        //textCursor().endEditBlock();
        _inputIndex = _prompt2.length();
    }

    ensureCursorVisible();

}


void SimpleConsole::updateLastValidCursor()
{
    QTextCursor cursor = textCursor();
    if( modificationAllowed(cursor) )
    {
        _lastValidCursor = cursor;
        setReadOnly(false);
    }
    else
    {
        setReadOnly(true);
    }
}


void SimpleConsole::executeCurrentCommand()
{
    if( !setState(ExecutingCommand) )
        return;

    // first move the cursor to the end of the document
    moveCursor(QTextCursor::End);

    // first add current line to the history
    historyAdd(currentLine());

    // extract command
    QString cmd = currentCommand();

    // put output in new block
    textCursor().insertBlock();

    // execute it
    emit execute(cmd);

    // append new prompt
    insertPrompt(true);
}

void SimpleConsole::executeCurrentCommand(QString CMD)
{
    if( !setState(ExecutingCommand) )
        return;

    // first move the cursor to the end of the document
    moveCursor(QTextCursor::End);

    // first add current line to the history
    historyAdd(currentLine());

    // extract command

    // put output in new block
    textCursor().insertBlock();

    // execute it
    emit execute(CMD);

    // append new prompt
    insertPrompt(true);
}


void SimpleConsole::extendMultilineCommand()
{
    // append line to history
    historyAdd(currentLine());

    // prompt for multiline command
    insertPrompt(false);
}


QString SimpleConsole::currentCommand() const
{
    // compose current command:

    QStringList lines = textCursor().block().text().split(QChar::LineSeparator);

    QString cmd = lines[0].mid(_prompt.length());
    for( int i = 1; i < lines.size(); i++ )
        cmd = cmd + "\n" + lines[i].mid(_prompt2.length());

    return cmd;
}


QString SimpleConsole::currentLine() const
{
    // use a cursor to get the current line
    QTextCursor cursor = textCursor();
    cursor.movePosition(QTextCursor::StartOfLine);
    cursor.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);

    // the current line
    QString line = cursor.selectedText().mid(_inputIndex);

    // we still need to remove the prompt
    return line;
}


QString SimpleConsole::waitForUserInput()
{
    // try to change state to user input!
    if( !setState(WaitingForUserInput) )
        return QString();

    // get length of previous text in the current line
    // and set the cursor to the end
    // and force update of lastValidCursor,
    // this indirectly sets readonly to false
    QTextCursor cursor = textCursor();
    cursor.movePosition(QTextCursor::End);
    setTextCursor(cursor);
    updateLastValidCursor();
    cursor.movePosition(QTextCursor::StartOfLine);
    _inputIndex = textCursor().position() - cursor.position();

    // start a new eventloop
    _userInputEventLoop->exec();

    // user input finished, so read current line
    QString userInput = currentLine();

    // set state back to executing
    setState(ExecutingCommand);

    // append new line after input
    htmlOutput("<br>");

    return userInput;
}


void SimpleConsole::setCurrentLine(QString newLine)
{
    // use a cursor to get the current line
    QTextCursor cursor = textCursor();
    cursor.movePosition(QTextCursor::StartOfLine);
    cursor.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);

    // save the current line
    QString line = cursor.selectedText();

    // we still need the prompt, so replace the rest
    line = line.left(_inputIndex) + newLine;

    // now replace the text under the cursor
    cursor.insertText(line);

    // update the cursor
    setTextCursor(cursor);
}


void SimpleConsole::historyAdd(QString line)
{
    if( line == "" )
        return;

    if( _history.empty() || _history.last() != line )
        _history.append(line);

    _historyPosition = _history.size();
}


void SimpleConsole::historyUp()
{
    if( _historyPosition > 0 )
        setCurrentLine(_history.at(--_historyPosition));
}


void SimpleConsole::historyDown()
{
    if( _historyPosition+1 < _history.size() )
        setCurrentLine(_history.at(++_historyPosition));
}


bool SimpleConsole::modificationAllowed(const QTextCursor &cursor) const
{
    if( !(_state == ShowCommandPrompt ||
          _state == WaitingForUserInput) )
        return false;

    int posOfLastLine = cursorPositionOfLastLine();

    // now check if we can modify it (it is in the last line?)
    return cursor.position() >=  posOfLastLine &&
            cursor.anchor()   >=  posOfLastLine;
}


bool SimpleConsole::positionCursor(const QKeyEvent *event)
{
    bool handled = true;

    // apply cursor movement
    QTextCursor cursor = textCursor();
    if( event->matches(QKeySequence::MoveToEndOfLine) )
        cursor.movePosition(QTextCursor::EndOfLine);

    else if( event->matches(QKeySequence::MoveToNextWord) )
        cursor.movePosition(QTextCursor::NextWord);

    else if( event->matches(QKeySequence::MoveToNextChar) )
        cursor.movePosition(QTextCursor::NextCharacter);

    else if( event->matches(QKeySequence::SelectEndOfLine) )
        cursor.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);

    else if( event->matches(QKeySequence::SelectNextWord) )
        cursor.movePosition(QTextCursor::NextWord, QTextCursor::KeepAnchor);

    else if( event->matches(QKeySequence::SelectNextChar) )
        cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);

    else if( event->matches(QKeySequence::MoveToPreviousWord) )
        cursor.movePosition(QTextCursor::PreviousWord);

    else if( event->matches(QKeySequence::MoveToPreviousChar) )
        cursor.movePosition(QTextCursor::PreviousCharacter);

    else if( event->matches(QKeySequence::SelectPreviousWord) )
        cursor.movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor);

    else if( event->matches(QKeySequence::SelectPreviousChar) )
        cursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor);

    // special cases for start of line
    else if( event->matches(QKeySequence::MoveToStartOfLine) )
    {
        cursor.movePosition(QTextCursor::StartOfLine);
        cursor.movePosition(QTextCursor::Right, QTextCursor::MoveAnchor, _prompt.length());
    }

    else if( event->matches(QKeySequence::SelectStartOfLine) )
    {
        cursor.movePosition(QTextCursor::StartOfLine, QTextCursor::KeepAnchor);
        cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor, _prompt.length());
    }
    else
    {
        handled = false;
    }


    // check if movement is allowed
    if( modificationAllowed(cursor) )
        setTextCursor(cursor);

    return handled;
}


void SimpleConsole::insertCompletion(QString word)
{
    // replace word under cursor
    QTextCursor cursor = textCursor();
    cursor.select(QTextCursor::WordUnderCursor);
    if( modificationAllowed(cursor) )
    {
        cursor.insertText( word );
    }
}


void SimpleConsole::requestAutocompletion()
{
    // check if we have a completer
    if( !_completer )
        return;

    // select current word
    QTextCursor cursor = textCursor();
    cursor.movePosition(QTextCursor::StartOfWord, QTextCursor::KeepAnchor);

    // popup / update the completer
    if( modificationAllowed(cursor) )
    {
        // update completion prefix
        if( _completer->completionPrefix() != cursor.selectedText() ||
                !_completer->popup()->isVisible()                       )
        {
            _completer->setCompletionPrefix( cursor.selectedText() );
            _completer->popup()->setCurrentIndex(_completer->completionModel()->index(0, 0));
        }
        //qDebug() << "requestAutocompletion with prefix: " << cursor.selectedText();


        // position the _completer popup correctly
        QRect cr = cursorRect(cursor);
        cr.setWidth(_completer->popup()->sizeHintForColumn(0) +
                    _completer->popup()->verticalScrollBar()->sizeHint().width());
        _completer->complete(cr);
    }
    else
    {
        // hide the completer
        _completer->popup()->hide();
    }
}


bool SimpleConsole::setState(SimpleConsole::ConsoleState newState)
{
    // if the new state is the same as before, everything is ok...
    if( newState == _state )
        return true;

    // at first we must show a command prompt
    if( _state == UndefinedConsoleState && newState == ShowCommandPrompt )
    {
        _state = newState;
        return true;
    }

    // if a command prompt is shown, we can execute something
    if( _state == ShowCommandPrompt && newState == ExecutingCommand )
    {
        _state = newState;
        return true;
    }

    // an executed command may need user input
    if( _state == ExecutingCommand && newState == WaitingForUserInput )
    {
        _state = newState;
        return true;
    }

    // after user input, execution continues
    if( _state == WaitingForUserInput && newState == ExecutingCommand )
    {
        _state = newState;
        return true;
    }

    // when the command execution finishes, we show a command prompt
    if( _state == ExecutingCommand && newState == ShowCommandPrompt )
    {
        _state = newState;
        return true;
    }

    // no other transitions possible
    qDebug() << "in SimpleConsole::insertPrompt: cannot switch from ConsoleState " << _state << " to " << newState << "!";
    return false;
}


int SimpleConsole::cursorPositionOfLastLine() const
{
    // get position of last line
    QTextCursor helperCursor = textCursor();
    helperCursor.movePosition(QTextCursor::End);
    helperCursor.movePosition(QTextCursor::StartOfLine);
    if( _state == ShowCommandPrompt || _state == WaitingForUserInput )
        helperCursor.movePosition(QTextCursor::Right, QTextCursor::MoveAnchor, _inputIndex);
    return helperCursor.position();
}


void SimpleConsole::setMaximumHistorySize(int maxSize)
{
    _maxHistSize = maxSize;

    // truncate history if necessary
    if( _history.size() > _maxHistSize )
    {
        QStringList::iterator start = _history.begin();
        QStringList::Iterator end = start + (_history.size() - _maxHistSize);
        _history.erase(start, end);

        _historyPosition = _history.size();
    }
}


void SimpleConsole::setHistory(QStringList newHistory)
{
    _history = newHistory;

    // truncate history if necessary
    setMaximumHistorySize(_maxHistSize);

    _historyPosition = _history.size();
}


void SimpleConsole::output(QString s)
{
    if( _state == ExecutingCommand || _state == UndefinedConsoleState )
        textCursor().insertText(s);
    else
        qDebug() << "Cannot handle console output when not in ExecutingCommand state! Output:\n" << s;
}


void SimpleConsole::htmlOutput(QString s)
{
    if( _state == ExecutingCommand || _state == UndefinedConsoleState )
        textCursor().insertHtml(s);
    else
        qDebug() << "Cannot handle console output when not in ExecutingCommand state! Output:\n" << s;
}