/*
 Copyright © 2017 Hasan Yavuz Özderya

 This file is part of serialplot.

 serialplot is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 serialplot is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with serialplot. If not, see <http://www.gnu.org/licenses/>.
*/

#include <QKeyEvent>

#include <QtDebug>

#include "commandedit.h"

class HexCommandValidator : public QRegExpValidator
{
public:
 explicit HexCommandValidator(QObject* parent = 0);
 QValidator::State validate(QString & input, int & pos) const;
};

HexCommandValidator::HexCommandValidator(QObject* parent) :
 QRegExpValidator(parent)
{
 QRegExp regExp("^(?:(?:[0-9A-F]{2}[ ])+(?:[0-9A-F]{2}))|(?:[0-9A-F]{2})$");
 setRegExp(regExp);
}

QValidator::State HexCommandValidator::validate(QString & input, int & pos) const
{
 input = input.toUpper();

 // don't let pos to be altered at this stage
 int orgPos = pos;
 auto r = QRegExpValidator::validate(input, pos);
 pos = orgPos;

 // try fixing up spaces
 if (r != QValidator::Acceptable)
 {
 input = input.replace(" ", "");
 input.replace(QRegExp("([0-9A-F]{2}(?!$))"), "\\1 ");
 if (pos == input.size()-1) pos = input.size();
 r = QRegExpValidator::validate(input, pos);
 }

 return r;
}

CommandEdit::CommandEdit(QWidget *parent) :
 QLineEdit(parent)
{
 hexValidator = new HexCommandValidator(this);
 asciiValidator = new QRegExpValidator(QRegExp("[\\x0000-\\x007F]+"), this);
 ascii_mode = true;
 setValidator(asciiValidator);
}

CommandEdit::~CommandEdit()
{
 delete hexValidator;
}

static QString unEscape(QString str);
static QString escape(QString str);

void CommandEdit::setMode(bool ascii)
{
 ascii_mode = ascii;
 if (ascii)
 {
 setValidator(asciiValidator);

 auto hexText = text().remove(" ");
 // try patching HEX string in case of missing nibble so that
 // input doesn't turn into gibberish
 if (hexText.size() % 2 == 1)
 {
 hexText.replace(hexText.size()-1, 1, "3F"); // 0x3F = '?'
 qWarning() << "Broken byte in hex command is replaced. Check your command!";
 }

 setText(escape(QByteArray::fromHex(hexText.toLatin1())));
 }
 else
 {
 setValidator(hexValidator);
 setText(unEscape(text()).toLatin1().toHex());
 }
}

void CommandEdit::keyPressEvent(QKeyEvent * event)
{
 if (ascii_mode)
 {
 QLineEdit::keyPressEvent(event);
 return;
 }

 if (event->key() == Qt::Key_Backspace && !hasSelectedText())
 {
 int cursor = cursorPosition();
 if (cursor != 0 && text()[cursor-1] == ' ')
 {
 setCursorPosition(cursor-1);
 }
 }

 QLineEdit::keyPressEvent(event);
}

QString CommandEdit::unEscapedText()
{
 return unEscape(text());
}

static QString unEscape(QString str)
{
 const QMap<QString, QString> replacements({
 {"\\\\", "\\"},
 {"\\n", "\n"},
 {"\\r", "\r"},
 {"\\t", "\t"}
 });

 QString result;

 int i = 0;
 while (i < str.size())
 {
 bool found = false;

 for (auto k : replacements.keys())
 {
 // has enough text left?
 if (str.size() - i < 1) continue;

 // try matching the key at current position
 if (k == str.midRef(i, k.size()))
 {
 // append replacement
 result += replacements[k];
 i += k.size();
 found = true;
 break; // skip other keys
 }
 }

 if (!found)
 {
 // append unmatched character
 result += str[i];
 i++;
 }
 }

 return result;
}

static QString escape(QString str)
{
 str.replace("\\", "\\\\");
 str.replace("\n", "\\n");
 str.replace("\r", "\\r");
 str.replace("\t", "\\t");
 return str;
}