#include "./tagfieldedit.h"
#include "./picturepreviewselection.h"

#include "../application/settings.h"
#include "../application/knownfieldmodel.h"

#include "../misc/utility.h"

#include <tagparser/tag.h>
#include <tagparser/tagvalue.h>
#include <tagparser/id3/id3v2tag.h>
#include <tagparser/mediafileinfo.h>

#include <qtutilities/widgets/clearlineedit.h>
#include <qtutilities/widgets/clearcombobox.h>
#include <qtutilities/widgets/clearspinbox.h>
#include <qtutilities/widgets/clearplaintextedit.h>
#include <qtutilities/widgets/iconbutton.h>

#include <c++utilities/conversion/conversionexception.h>

#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QLabel>
#include <QPushButton>
#include <QPlainTextEdit>
#include <QGraphicsView>
#include <QGraphicsScene>
#include <QGraphicsTextItem>
#include <QFile>
#include <QImage>
#include <QEvent>
#include <QKeyEvent>
#include <QListIterator>
#include <QCursor>
#include <QMenu>
#include <QAction>

#include <initializer_list>
#include <algorithm>
#include <functional>
#include <iostream>

using namespace std;
using namespace Models;
using namespace Widgets;
using namespace Media;
using namespace ConversionUtilities;

namespace QtGui {

/*!
 * \class QtGui::TagFieldEdit
 * \brief The TagFieldEdit widget allows the user to edit a specified tag field.
 */

/*!
 * \brief Constructs a new TagFieldEdit.
 * \sa setTagField()
 */
TagFieldEdit::TagFieldEdit(const QList<Media::Tag *> &tags, Media::KnownField field, QWidget *parent) :
    QWidget(parent),
    m_layout(new QVBoxLayout(this)),
    m_tags(&tags),
    m_field(field),
    m_dataType(determineDataType()),
    m_lineEdit(nullptr),
    m_comboBox(nullptr),
    m_spinBoxes(QPair<Widgets::ClearSpinBox *, Widgets::ClearSpinBox *>(nullptr, nullptr)),
    m_pictureSelection(nullptr),
    m_plainTextEdit(nullptr),
    m_descriptionLineEdit(nullptr),
    m_restoreButton(nullptr)
{
    m_layout->setContentsMargins(QMargins());
    setLayout(m_layout);
    setupUi();
    updateValue();
}

/*!
 * \brief Assigns the specified \a tags and sets the specified \a fields using the given \a previousValueHandling.
 *
 * If \a preventUiUpdate is true, the UI will not be updated.
 */
void TagFieldEdit::setTagField(const QList<Tag *> &tags, Media::KnownField field, PreviousValueHandling previousValueHandling, bool preventUiUpdate)
{
    bool uiRebuildingRequired = false;
    m_tags = &tags;
    if(m_field != field) {
        m_field = field;
        uiRebuildingRequired = true;
    }
    if(tags.size()) {
        TagDataType proposedDataType = determineDataType();
        if(proposedDataType != m_dataType) {
            m_dataType = proposedDataType;
            uiRebuildingRequired = true;
        }
    }
    if(!preventUiUpdate) {
        if(uiRebuildingRequired) {
            setupUi();
        }
        updateValue(previousValueHandling);
    }
}

/*!
 * \brief Returns the currently shown value.
 * \remarks
 * - The specified \a encoding is used to encode text values.
 * - Does not work for values of the type picture.
 */
TagValue TagFieldEdit::value(TagTextEncoding encoding, bool includeDescription) const
{
    TagValue value;
    switch(m_dataType) {
    case TagDataType::Text:
    case TagDataType::TimeSpan:
    case TagDataType::DateTime:
        switch(m_field) {
        case KnownField::Genre:
            if(m_comboBox) {
                value.assignText(Utility::qstringToString(m_comboBox->currentText(), encoding), encoding);
            }
            break;
        case KnownField::Lyrics:
            if(m_plainTextEdit) {
                value.assignText(Utility::qstringToString(m_plainTextEdit->toPlainText(), encoding), encoding);
            }
            break;
        default:
            if(m_lineEdit) {
                value.assignText(Utility::qstringToString(m_lineEdit->text(), encoding), encoding);
            }
        }
        break;
    case TagDataType::Integer:
        if(m_spinBoxes.first && m_spinBoxes.first->value()) {
            value.assignInteger(m_spinBoxes.first->value());
        }
        break;
    case TagDataType::PositionInSet:
        if(m_spinBoxes.first && m_spinBoxes.second) {
            value.assignPosition(PositionInSet(m_spinBoxes.first->value(), m_spinBoxes.second->value()));
        }
        break;
    case TagDataType::StandardGenreIndex:
        if(m_comboBox) {
            value.assignText(Utility::qstringToString(m_comboBox->currentText(), encoding), encoding);
        }
        break;
    default:
        ;
    }
    if(m_descriptionLineEdit && includeDescription) { // setup description line edit
        value.setDescription(Utility::qstringToString(m_descriptionLineEdit->text(), encoding), encoding);
    }
    return value;
}

/*!
 * \brief Sets the \a value of the current tag field manually using the given \a previousValueHandling.
 */
bool TagFieldEdit::setValue(const TagValue &value, PreviousValueHandling previousValueHandling)
{
    updateValue(value, previousValueHandling, false);
    if(m_pictureSelection) {
        m_pictureSelection->setValue(value, previousValueHandling);
    }
    return true;
}

/*!
 * \brief Returns whether at least one of the assigned tags supports a description for the current field.
 */
bool TagFieldEdit::hasDescription() const
{
    for(Tag *tag : tags()) {
        if(tag->supportsDescription(m_field)) {
            return true;
        }
    }
    return false;
}

/*!
 * \brief Returns an indication whether the specified \a field can be applied.
 */
bool TagFieldEdit::canApply(KnownField field) const
{
    for(Tag *tag : tags()) {
        switch(tag->type()) {
        case TagType::Id3v1Tag:
            if(Settings::id3v1usage() == TagUsage::Never) {
                continue;
            }
            break;
        case TagType::Id3v2Tag:
            if(Settings::id3v2usage() == TagUsage::Never) {
                continue;
            }
            break;
        default:
            ;
        }
        if(tag->supportsField(field)) {
            return true;
        }
    }
    return false;
}

/*!
 * \brief Sets whether the cover buttons are hidden.
 */
void TagFieldEdit::setCoverButtonsHidden(bool hideCoverButtons)
{
    if(m_pictureSelection) {
        m_pictureSelection->setCoverButtonsHidden(hideCoverButtons);
    }
}

/*!
 * \brief Internally called to determine the data type of the current tag field.
 */
TagDataType TagFieldEdit::determineDataType()
{
    TagDataType proposedDataType = TagDataType::Undefined;
    for(Tag *tag : tags()) {
        TagDataType type = tag->proposedDataType(m_field);
        if(proposedDataType == TagDataType::Undefined) {
            proposedDataType = type;
        } else if((proposedDataType == TagDataType::PositionInSet && type == TagDataType::Integer)
                  || (type == TagDataType::PositionInSet && proposedDataType == TagDataType::Integer)) {
            proposedDataType = TagDataType::PositionInSet; // PositionInSet and Number can be considered as compatible
        } else if(type == TagDataType::Undefined || type != proposedDataType) {
            return TagDataType::Undefined; // undefined or different (incompatible) types proposed
        }
    }
    return proposedDataType;
}

/*!
 * \brief Internally called to setup the UI.
 *
 * Causes the previous UI widgets to be destroyed. Any unapplied changes are lost.
 */
void TagFieldEdit::setupUi()
{
    // remove previous widgets
    m_lineEdit = nullptr;
    m_comboBox = nullptr;
    m_spinBoxes.first = nullptr;
    m_spinBoxes.second = nullptr;
    m_pictureSelection = nullptr;
    m_plainTextEdit = nullptr;
    m_descriptionLineEdit = nullptr;
    qDeleteAll(m_widgets);
    m_widgets.clear();
    // setup widgets
    switch(m_dataType) {
    case TagDataType::Text:
    case TagDataType::TimeSpan:
    case TagDataType::DateTime:
        switch(m_field) {
        case KnownField::Genre:
            setupGenreComboBox();
            break;
        case KnownField::Lyrics:
            setupPlainTextEdit();
            break;
        default:
            setupLineEdit();
        }
        break;
    case TagDataType::Picture:
        setupPictureSelection();
        break;
    case TagDataType::Integer:
        setupSpinBox();
        break;
    case TagDataType::PositionInSet:
        setupPositionInSetSpinBoxes();
        break;
    case TagDataType::StandardGenreIndex:
        setupGenreComboBox();
        break;
    case TagDataType::Binary:
        setupFileSelection();
        break;
    default:
        setupTypeNotSupportedLabel();
        ;
    }
    if(m_dataType != TagDataType::Picture
            && hasDescription()) { // setup description line edit
        setupDescriptionLineEdit();
    }
}

/*!
 * \brief Internally called by setupUi() to setup a line edit.
 */
ClearLineEdit *TagFieldEdit::setupLineEdit()
{
    m_lineEdit = new ClearLineEdit(this);
    m_lineEdit->setPlaceholderText(tr("empty"));
    static_cast<ButtonOverlay *>(m_lineEdit)->setClearButtonEnabled(true);
    m_lineEdit->insertCustomButton(0, setupRestoreButton());
    m_lineEdit->installEventFilter(this);
    connect(m_lineEdit, &ClearLineEdit::textChanged, this, &TagFieldEdit::showRestoreButton);
    m_layout->addWidget(m_lineEdit);
    m_widgets << m_lineEdit;
    return m_lineEdit;
}

/*!
 * \brief Internally called by setupUi() to setup a plain text edit.
 */
ClearPlainTextEdit *TagFieldEdit::setupPlainTextEdit()
{
    m_plainTextEdit = new ClearPlainTextEdit(this);
    m_plainTextEdit->setClearButtonEnabled(true);
    m_plainTextEdit->insertCustomButton(0, setupRestoreButton());
    connect(m_plainTextEdit->document(), &QTextDocument::contentsChanged, this, &TagFieldEdit::showRestoreButton);
    m_layout->addWidget(m_plainTextEdit);
    m_widgets << m_plainTextEdit;
    return m_plainTextEdit;
}

/*!
 * \brief Internally called by setupUi() to setup a combo box.
 */
ClearComboBox *TagFieldEdit::setupGenreComboBox()
{
    m_comboBox = new ClearComboBox(this);
    m_comboBox->setEditable(true);
    if(QLineEdit *lineEdit = m_comboBox->lineEdit()) {
        lineEdit->setPlaceholderText(tr("empty"));
    }
    m_comboBox->addItems(QStringList()
                         << QString()
                         << tr("Blues")
                         << tr("A capella")
                         << tr("Abstract")
                         << tr("Acid")
                         << tr("Acid Jazz")
                         << tr("Acid Punk")
                         << tr("Acoustic")
                         << tr("Alternative")
                         << tr("Alternative Rock")
                         << tr("Ambient")
                         << tr("Anime")
                         << tr("Art Rock")
                         << tr("Audio Theatre")
                         << tr("Audiobook")
                         << tr("Avantgarde")
                         << tr("Ballad")
                         << tr("Baroque")
                         << tr("Bass")
                         << tr("Beat")
                         << tr("Bebop")
                         << tr("Bhangra")
                         << tr("Big Band")
                         << tr("Big Beat")
                         << tr("Black Metal")
                         << tr("Bluegrass")
                         << tr("Booty Bass")
                         << tr("Breakbeat")
                         << tr("BritPop")
                         << tr("Cabaret")
                         << tr("Celtic")
                         << tr("Chamber Music")
                         << tr("Chanson")
                         << tr("Chillout")
                         << tr("Chorus")
                         << tr("Christian Gangsta Rap")
                         << tr("Christian Rap")
                         << tr("Christian Rock")
                         << tr("Classic Rock")
                         << tr("Classical")
                         << tr("Club")
                         << tr("Club-House")
                         << tr("Comedy")
                         << tr("Contemporary Christian")
                         << tr("Country")
                         << tr("Crossover")
                         << tr("Cult")
                         << tr("Dance")
                         << tr("Dance Hall")
                         << tr("Darkwave")
                         << tr("Death Metal")
                         << tr("Disco")
                         << tr("Downtempo")
                         << tr("Dream")
                         << tr("Drum & Bass")
                         << tr("Drum Solo")
                         << tr("Dub")
                         << tr("Dubstep")
                         << tr("Duet")
                         << tr("Easy Listening")
                         << tr("EBM")
                         << tr("Eclectic")
                         << tr("Electro")
                         << tr("Electroclash")
                         << tr("Electronic")
                         << tr("Emo")
                         << tr("Ethnic")
                         << tr("Euro-House")
                         << tr("Euro-Techno")
                         << tr("Eurodance")
                         << tr("Experimental")
                         << tr("Fast Fusion")
                         << tr("Folk")
                         << tr("Folk-Rock")
                         << tr("Folklore")
                         << tr("Freestyle")
                         << tr("Funk")
                         << tr("Fusion")
                         << tr("G-Funk")
                         << tr("Game")
                         << tr("Gangsta")
                         << tr("Garage")
                         << tr("Garage Rock")
                         << tr("Global")
                         << tr("Goa")
                         << tr("Gospel")
                         << tr("Gothic")
                         << tr("Gothic Rock")
                         << tr("Grunge")
                         << tr("Hard Rock")
                         << tr("Hardcore Techno")
                         << tr("Heavy Metal")
                         << tr("Hip-Hop")
                         << tr("House")
                         << tr("Humour")
                         << tr("IDM")
                         << tr("Illbient")
                         << tr("Indie")
                         << tr("Indie Rock")
                         << tr("Industrial")
                         << tr("Industro-Goth")
                         << tr("Instrumental")
                         << tr("Instrumental Pop")
                         << tr("Instrumental Rock")
                         << tr("Jam Band")
                         << tr("Jazz")
                         << tr("Jazz & Funk")
                         << tr("Jpop")
                         << tr("Jungle")
                         << tr("Krautrock")
                         << tr("Latin")
                         << tr("Leftfield")
                         << tr("Lo-Fi")
                         << tr("Lounge")
                         << tr("Math Rock")
                         << tr("Meditative")
                         << tr("Merengue")
                         << tr("Metal")
                         << tr("Musical")
                         << tr("National Folk")
                         << tr("Native US")
                         << tr("Negerpunk")
                         << tr("Neoclassical")
                         << tr("Neue Deutsche Welle")
                         << tr("New Age")
                         << tr("New Romantic")
                         << tr("New Wave")
                         << tr("Noise")
                         << tr("Nu-Breakz")
                         << tr("Oldies")
                         << tr("Opera")
                         << tr("Podcast")
                         << tr("Polka")
                         << tr("Polsk Punk")
                         << tr("Pop")
                         << tr("Pop-Folk")
                         << tr("Pop/Funk")
                         << tr("Porn Groove")
                         << tr("Post-Punk")
                         << tr("Post-Rock")
                         << tr("Power Ballad")
                         << tr("Pranks")
                         << tr("Primus")
                         << tr("Progressive Rock")
                         << tr("Psychedelic")
                         << tr("Psychedelic Rock")
                         << tr("Psytrance")
                         << tr("Punk")
                         << tr("Punk Rock")
                         << tr("Rap")
                         << tr("Rave")
                         << tr("Reggae")
                         << tr("Retro")
                         << tr("Revival")
                         << tr("Rhythmic Soul")
                         << tr("Rock")
                         << tr("Rock & Roll")
                         << tr("Salsa")
                         << tr("Samba")
                         << tr("Satire")
                         << tr("Shoegaze")
                         << tr("Showtunes")
                         << tr("Ska")
                         << tr("Slow Jam")
                         << tr("Slow Rock")
                         << tr("Sonata")
                         << tr("Soul")
                         << tr("Sound Clip")
                         << tr("Soundtrack")
                         << tr("Southern Rock")
                         << tr("Space")
                         << tr("Space Rock")
                         << tr("Speech")
                         << tr("Swing")
                         << tr("Symphonic Rock")
                         << tr("Symphony")
                         << tr("Synthpop")
                         << tr("Tango")
                         << tr("Techno")
                         << tr("Techno-Industrial")
                         << tr("Terror")
                         << tr("Thrash Metal")
                         << tr("Top 40")
                         << tr("Trailer")
                         << tr("Trance")
                         << tr("Tribal")
                         << tr("Trip-Hop")
                         << tr("Trop Rock")
                         << tr("Vocal")
                         << tr("World Music"));
    m_comboBox->setCurrentIndex(0);
    m_comboBox->setClearButtonEnabled(true);
    m_comboBox->insertCustomButton(0, setupRestoreButton());
    m_comboBox->installEventFilter(this);
    m_comboBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    connect(m_comboBox, &ClearComboBox::currentTextChanged, this, &TagFieldEdit::showRestoreButton);

    m_layout->addWidget(m_comboBox);
    m_widgets << m_comboBox;
    return m_comboBox;
}

/*!
 * \brief Internally called by setupUi() to setup a single spin box.
 */
ClearSpinBox *TagFieldEdit::setupSpinBox()
{
    m_spinBoxes.first = new ClearSpinBox(this);
    m_spinBoxes.first->setPlaceholderText(tr("empty"));
    m_spinBoxes.first->setMinimumHidden(true);
    m_spinBoxes.first->setClearButtonEnabled(true);
    m_spinBoxes.first->insertCustomButton(0, setupRestoreButton());
    m_spinBoxes.first->installEventFilter(this);
    m_spinBoxes.first->setMaximum(32766);
    connect(m_spinBoxes.first, static_cast<void (ClearSpinBox::*)(int)>(&ClearSpinBox::valueChanged), this, &TagFieldEdit::showRestoreButton);
    m_layout->addWidget(m_spinBoxes.first);
    m_widgets << m_spinBoxes.first;
    return m_spinBoxes.first;
}

/*!
 * \brief Internally called by setupUi() to setup a a pair of spin boxes.
 */
QPair<Widgets::ClearSpinBox *, Widgets::ClearSpinBox *> &TagFieldEdit::setupPositionInSetSpinBoxes()
{
    QHBoxLayout *subLayout = new QHBoxLayout;

    m_spinBoxes.first = new ClearSpinBox(this);
    m_spinBoxes.first->setPlaceholderText(tr("empty"));
    m_spinBoxes.first->setMinimumHidden(true);
    m_spinBoxes.first->setClearButtonEnabled(true);
    m_spinBoxes.first->installEventFilter(this);
    m_spinBoxes.first->setMaximum(32766);
    m_spinBoxes.first->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    connect(m_spinBoxes.first, static_cast<void (ClearSpinBox::*)(int)>(&ClearSpinBox::valueChanged), this, &TagFieldEdit::showRestoreButton);
    subLayout->addWidget(m_spinBoxes.first);
    m_widgets << m_spinBoxes.first;

    QLabel *label = new QLabel(tr("of"), this);
    subLayout->addWidget(label);
    m_widgets << label;

    m_spinBoxes.second = new ClearSpinBox(this);
    m_spinBoxes.second->setPlaceholderText(tr("empty"));
    m_spinBoxes.second->setMinimumHidden(true);
    m_spinBoxes.second->setClearButtonEnabled(true);
    m_spinBoxes.second->installEventFilter(this);
    m_spinBoxes.second->setMaximum(32766);
    m_spinBoxes.second->insertCustomButton(0, setupRestoreButton());
    m_spinBoxes.second->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    connect(m_spinBoxes.second, static_cast<void (ClearSpinBox::*)(int)>(&ClearSpinBox::valueChanged), this, &TagFieldEdit::showRestoreButton);
    subLayout->addWidget(m_spinBoxes.second);
    m_widgets << m_spinBoxes.second;

    m_layout->addLayout(subLayout);
    return m_spinBoxes;
}

/*!
 * \brief Internally called by setupUi() to setup a PicturePreviewSelection widget.
 */
PicturePreviewSelection *TagFieldEdit::setupPictureSelection()
{
    m_pictureSelection = new PicturePreviewSelection(nullptr, KnownField::Invalid, this);
    connect(m_pictureSelection, &PicturePreviewSelection::pictureChanged, this, &TagFieldEdit::showRestoreButton);
    m_layout->addWidget(m_pictureSelection);
    m_widgets << m_pictureSelection;
    return m_pictureSelection;
}

/*!
 * \brief Internally called by setupUi() to setup a file selection.
 * \remarks TODO
 */
QWidget *TagFieldEdit::setupFileSelection()
{
    return setupTypeNotSupportedLabel();
}

/*!
 * \brief Internally called by setupUi() to setup a line edit for the description.
 */
ClearLineEdit *TagFieldEdit::setupDescriptionLineEdit()
{
    QLabel *label = new QLabel(tr("Description"), this);
    m_layout->addWidget(label);

    m_widgets << label;
    m_descriptionLineEdit = new ClearLineEdit(this);
    m_descriptionLineEdit->setPlaceholderText(tr("empty"));
    static_cast<ButtonOverlay *>(m_descriptionLineEdit)->setClearButtonEnabled(true);
    m_descriptionLineEdit->installEventFilter(this);
    connect(m_descriptionLineEdit, &ClearLineEdit::textChanged, this, &TagFieldEdit::showRestoreButton);

    m_layout->addWidget(m_descriptionLineEdit);
    m_widgets << m_descriptionLineEdit;
    return m_descriptionLineEdit;
}

/*!
 * \brief Internally called by setupUi() to setup a label indicating that the current tag field is not supported by the edit.
 */
QLabel *TagFieldEdit::setupTypeNotSupportedLabel()
{
    QLabel *label = new QLabel(tr("editing widget for field type not supported"), this);
    m_layout->addWidget(label);
    m_widgets << label;
    return label;
}

/*!
 * \brief Updates the currently shown value manually.
 * \param previousValueHandling Specifies how to deal with the previous value.
 *
 * The new value is read from the assigned tag(s).
 */
void TagFieldEdit::updateValue(PreviousValueHandling previousValueHandling)
{
    QListIterator<Tag *> i(tags());
    i.toBack();
    bool pictureSelectionUpdated = false;
    while(i.hasPrevious()) {
        Tag *tag = i.previous();
        const TagValue &value = tag->value(m_field);
        if(!value.isEmpty()) {
            updateValue(value, previousValueHandling);
            if(m_pictureSelection) {
                m_pictureSelection->setTagField(tag, m_field, previousValueHandling);
                pictureSelectionUpdated = true;
            }
            return;
        }
    }
    updateValue(TagValue::empty(), previousValueHandling);
    if(m_pictureSelection && !pictureSelectionUpdated) {
        if(m_tags->size()) {
            m_pictureSelection->setTagField(m_tags->last(), m_field, previousValueHandling);
        } else {
            m_pictureSelection->setTagField(nullptr, m_field, previousValueHandling);
        }
    }
}

/*!
 * \brief Updates the currently shown value manually.
 * \param tag Specifies the tag to read the new value from.
 * \param previousValueHandling Specifies how to deal with the previous value.
 * \remarks If \a tag is nullptr, the new value is empty.
 */
void TagFieldEdit::updateValue(Tag *tag, PreviousValueHandling previousValueHandling)
{
    if(tag) {
        updateValue(tag->value(m_field), previousValueHandling);
    } else {
        updateValue(TagValue::empty(), previousValueHandling);
    }
    if(m_pictureSelection) {
        m_pictureSelection->setTagField(tag, m_field, previousValueHandling);
    }
}

/*!
 * \brief Updates the currently shown value manually.
 * \param value Specifies the new value.
 * \param previousValueHandling Specifies how to deal with the previous value.
 * \param updateRestoreButton Specifies whether the "restore button" should be updated.
 * \remarks Does not update the picture preview selection.
 */
void TagFieldEdit::updateValue(const TagValue &value, PreviousValueHandling previousValueHandling, bool updateRestoreButton)
{
    bool conversionError = false;
    bool updated = false;
    concretizePreviousValueHandling(previousValueHandling);
    if(m_lineEdit || m_comboBox || m_plainTextEdit) {
        QString text;
        try {
            text = Utility::tagValueToQString(value);
        } catch (const ConversionException &) {
            conversionError = true;
        }
        applyAutoCorrection(text);
        if(previousValueHandling == PreviousValueHandling::Clear || !text.isEmpty()) {
            if(m_lineEdit && (previousValueHandling != PreviousValueHandling::Keep || m_lineEdit->isCleared())) {
                m_lineEdit->setText(text);
                updated = true;
            }
            if(m_comboBox && (previousValueHandling != PreviousValueHandling::Keep || m_comboBox->isCleared())) {
                m_comboBox->setCurrentText(text);
                updated = true;
            }
            if(m_plainTextEdit && (previousValueHandling != PreviousValueHandling::Keep || m_plainTextEdit->isCleared())) {
                m_plainTextEdit->setPlainText(text);
                updated = true;
            }
        }
    }
    if(m_spinBoxes.first) {
        if(m_spinBoxes.second) {
            PositionInSet pos;
            try {
                pos = value.toPositionInSet();
            } catch(const ConversionException &) {
                conversionError = true;
            }
            if(previousValueHandling == PreviousValueHandling::Clear || pos.position()) {
                if(previousValueHandling != PreviousValueHandling::Keep || m_spinBoxes.first->isCleared()) {
                    m_spinBoxes.first->setValue(pos.position());
                    updated = true;
                }
            } else if(previousValueHandling == PreviousValueHandling::IncrementUpdate && !m_spinBoxes.first->isCleared()) {
                m_spinBoxes.first->setValue(m_spinBoxes.first->value() + 1);
                updated = true;
            }
            if(previousValueHandling == PreviousValueHandling::Clear || pos.total()) {
                if(previousValueHandling != PreviousValueHandling::Keep || m_spinBoxes.second->isCleared()) {
                    m_spinBoxes.second->setValue(pos.total());
                    updated = true;
                }
            }
        } else {
            int num;
            try {
                num = value.toInteger();
            } catch(const ConversionException &) {
                conversionError = true;
                num = 0;
            }
            if(previousValueHandling == PreviousValueHandling::Clear || num) {
                if(previousValueHandling != PreviousValueHandling::Keep || m_spinBoxes.first->isCleared()) {
                    m_spinBoxes.first->setValue(num);
                    updated = true;
                }
            } else if(previousValueHandling == PreviousValueHandling::IncrementUpdate && !m_spinBoxes.first->isCleared()) {
                m_spinBoxes.first->setValue(m_spinBoxes.first->value() + 1);
                updated = true;
            }
        }
    }
    if(m_descriptionLineEdit && (previousValueHandling != PreviousValueHandling::Keep || m_descriptionLineEdit->isCleared())) {
        try {
            QString desc = Utility::stringToQString(value.description(), value.descriptionEncoding());
            applyAutoCorrection(desc);
            m_descriptionLineEdit->setText(desc);
        } catch(const ConversionException &) {
            conversionError = true;
            m_descriptionLineEdit->clear();
        }
    }
    if(updateRestoreButton && m_restoreButton) {
        m_restoreButton->setVisible((!updated && m_restoreButton->isVisible()) || m_tags->size() > 1);
    }
    const initializer_list<ButtonOverlay *> widgets = {m_lineEdit, m_comboBox, m_spinBoxes.first, m_spinBoxes.second};
    bool canApply = this->canApply(m_field);
    if(conversionError || !canApply) {
        QPixmap pixmap = style()->standardPixmap(QStyle::SP_MessageBoxCritical).scaled(16, 16);
        QString text;
        if(conversionError) {
            text = tr("The value of this field could not be read from the file because it couldn't be converted proberly.");
            if(!canApply) {
                text += "\n";
            }
        }
        if(!canApply) {
            text += tr("The field can not be applied when saving the file and will be lost.");
        }
        for(ButtonOverlay *overlay : widgets) {
            if(overlay) {
                overlay->enableInfoButton(pixmap, text);
            }
        }
    } else {
        for(ButtonOverlay *overlay : widgets) {
            if(overlay) {
                overlay->disableInfoButton();
            }
        }
    }
}

/*!
 * \brief Internally called by the other setup methods to create the "restore button".
 */
IconButton *TagFieldEdit::setupRestoreButton()
{
    if(!m_restoreButton) { // setup restore button
        m_restoreButton = new IconButton(this);
        m_restoreButton->setPixmap(/*QIcon::fromTheme(QStringLiteral("edit-undo"), */QIcon(QStringLiteral(":/qtutilities/icons/hicolor/16x16/actions/edit-menu.png")/*)*/).pixmap(16));
        m_restoreButton->setToolTip(tr("restore"));
        connect(m_restoreButton, &IconButton::clicked, this, &TagFieldEdit::handleRestoreButtonClicked);
        // ownership might be transfered to a child widget/layout
        connect(m_restoreButton, &IconButton::destroyed, this, &TagFieldEdit::handleRestoreButtonDestroyed);
    }
    return m_restoreButton;
}

/*!
 * \brief Internally called to show the restore button (if there is one and at least one tag is assigned).
 */
void TagFieldEdit::showRestoreButton()
{
    if(m_restoreButton) {
        m_restoreButton->setVisible(m_tags->size());
    }
}

/*!
 * \brief Applies auto correction (according to the settings) for the specified \a textValue.
 */
void TagFieldEdit::applyAutoCorrection(QString &textValue)
{
    auto &fields = Settings::autoCorrectionFields().items();
    auto i = find_if(fields.constBegin(), fields.constEnd(), [this] (const ChecklistItem &item) {
        bool ok;
        return (item.id().toInt(&ok) == static_cast<int>(this->field())) && ok;
    });
    // if current field is in the list of auto correction fields and auto correction should be applied
    if(i != fields.constEnd() && i->isChecked()) {
        if(Settings::trimWhitespaces()) {
            textValue = textValue.trimmed();
        }
        if(Settings::fixUmlauts()) {
            textValue = Utility::fixUmlauts(textValue);
        }
        if(Settings::formatNames()) {
            textValue = Utility::formatName(textValue);
        }
    }
}

/*!
 * \brief If \a previousValueHandling is PreviousValueHandling::Auto it will be set to a concrete value.
 */
void TagFieldEdit::concretizePreviousValueHandling(PreviousValueHandling &previousValueHandling)
{
    switch(previousValueHandling) {
    case PreviousValueHandling::Auto:
        switch(m_field) {
        // these differ for each song -> always clear previous value
        case KnownField::Title:
        case KnownField::Lyrics:
            previousValueHandling = PreviousValueHandling::Clear;
            break;
        // these will be incremented
        case KnownField::TrackPosition:
        case KnownField::PartNumber:
            previousValueHandling = PreviousValueHandling::IncrementUpdate;
            break;
        default:
            previousValueHandling = PreviousValueHandling::Update;
        }
    default:
        ;
    }
}

/*!
 * \brief Restores the current value to the initial value.
 */
void TagFieldEdit::restore()
{
    updateValue(PreviousValueHandling::Clear);
}

/*!
 * \brief Clears the current value.
 */
void TagFieldEdit::clear()
{
    if(m_lineEdit) {
        m_lineEdit->clear();
    }
    if(m_comboBox) {
        m_comboBox->setCurrentText(QString());
    }
    if(m_plainTextEdit) {
        m_plainTextEdit->clear();
    }
    if(m_spinBoxes.first) {
        m_spinBoxes.first->setValue(0);
    }
    if(m_spinBoxes.second) {
        m_spinBoxes.second->setValue(0);
    }
    if(m_pictureSelection) {
        m_pictureSelection->clear();
    }
    if(m_descriptionLineEdit) {
        m_descriptionLineEdit->clear();
    }
}

/*!
 * \brief Applies the current value to the assigned tag.
 */
void TagFieldEdit::apply()
{
    for(Tag *tag : *m_tags) {
        if(m_dataType == TagDataType::Picture) {
            if(m_pictureSelection) {
                m_pictureSelection->apply();
            }
        } else {
            TagTextEncoding encoding = Settings::preferredEncoding();
            if(!tag->canEncodingBeUsed(encoding)) {
                encoding = tag->proposedTextEncoding();
            }
            tag->setValue(m_field, value(encoding, tag->supportsDescription(m_field)));
        }
    }
}

/*!
 * \brief Handles different key events.
 */
bool TagFieldEdit::eventFilter(QObject *obj, QEvent *event)
{
    switch(event->type()) {
    case QEvent::KeyRelease: {
        auto *keyEvent = static_cast<QKeyEvent *>(event);
        int key = keyEvent->key();
        switch(key) {
        case Qt::Key_Return:
            emit returnPressed();
            break;
        case Qt::Key_Shift:
            if(keyEvent->modifiers() & Qt::ControlModifier) {
                if(QLineEdit *le = qobject_cast<QLineEdit *>(obj)) {
                    le->setText(Utility::formatName(le->text()));
                    return true;
                }
            }
            break;
        default:
            ;
        }
        break;
    } default:
        ;
    }
    return QWidget::eventFilter(obj, event);
}

/*!
 * \brief Called when the restore button has been clicked.
 */
void TagFieldEdit::handleRestoreButtonClicked()
{
    if(tags().size()) {
        QMenu menu;
        int i = 0;
        for(Tag *tag : tags()) {
            ++i;
            QAction *action = menu.addAction(tr("restore to value from %1 (%2)").arg(tag->typeName()).arg(i));
            connect(action, &QAction::triggered, std::bind(static_cast<void (TagFieldEdit::*) (Tag *, PreviousValueHandling)>(&TagFieldEdit::updateValue), this, tag, PreviousValueHandling::Clear));
        }
        menu.exec(QCursor::pos());
    } else {
        restore();
    }
}

/*!
 * \brief Sets m_restoreButton to nullptr when the restore button has been destroyed.
 */
void TagFieldEdit::handleRestoreButtonDestroyed(QObject *obj)
{
    if(obj == m_restoreButton) {
        m_restoreButton = nullptr;
    }
}

}