/***************************************************************************
 *   This file is part of the Lime Report project                          *
 *   Copyright (C) 2021 by Alexander Arin                                  *
 *   arin_a@bk.ru                                                          *
 *                                                                         *
 **                   GNU General Public License Usage                    **
 *                                                                         *
 *   This library 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.                                   *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 *                                                                         *
 **                  GNU Lesser General Public License                    **
 *                                                                         *
 *   This library is free software: you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as        *
 *   published by the Free Software Foundation, either version 3 of the    *
 *   License, or (at your option) any later version.                       *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library.                                      *
 *   If not, see <http://www.gnu.org/licenses/>.                           *
 *                                                                         *
 *   This library 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.                          *
 ****************************************************************************/
#include "lrobjectitemmodel.h"

#include <QDebug>
#include <QMessageBox>
#include <QMetaProperty>
#include <QPainter>

namespace LimeReport {

void QObjectPropertyModel::translatePropertyName()
{
    tr("leftMargin");
    tr("rightMargin");
    tr("topMargin");
    tr("bottomMargin");
    tr("objectName");
    tr("borders");
    tr("geometry");
    tr("itemAlign");
    tr("pageOrientation");
    tr("pageSize");
    tr("TopLine");
    tr("BottomLine");
    tr("LeftLine");
    tr("RightLine");
    tr("reprintOnEachPage");
    tr("borderLineSize");
    tr("autoHeight");
    tr("backgroundColor");
    tr("columnCount");
    tr("columnsFillDirection");
    tr("datasource");
    tr("keepBottomSpace");
    tr("keepFooterTogether");
    tr("keepSubdetailTogether");
    tr("printIfEmpty");
    tr("sliceLastRow");
    tr("splittable");
    tr("alignment");
    tr("angle");
    tr("autoWidth");
    tr("backgroundMode");
    tr("backgroundOpacity");
    tr("content");
    tr("font");
    tr("fontColor");
    tr("foregroundOpacity");
    tr("itemLocation");
    tr("margin");
    tr("stretchToMaxHeight");
    tr("trimValue");
    tr("lineWidth");
    tr("opacity");
    tr("penStyle");
    tr("shape");
    tr("shapeBrush");
    tr("shapeBrushColor");
    tr("gridStep");
    tr("fullPage");
    tr("oldPrintMode");
    tr("borderColor");
    tr("resetPageNumber");
    tr("alternateBackgroundColor");
    tr("backgroundBrushStyle");
    tr("columnCount");
    tr("startFromNewPage");
    tr("startNewPage");
    tr("adaptFontToSize");
    tr("allowHTML");
    tr("allowHTMLInFields");
    tr("backgroundBrushStyle");
    tr("followTo");
    tr("format");
    tr("lineSpacing");
    tr("textIndent");
    tr("textLayoutDirection");
    tr("underlineLineSize");
    tr("underlines");
    tr("valueType");
    tr("securityLevel");
    tr("testValue");
    tr("whitespace");
    tr("resourcePath");
    tr("scale");
    tr("cornerRadius");
    tr("shapeColor");
    tr("layoutType");
    tr("barcodeType");
    tr("barcodeWidth");
    tr("foregroundColor");
    tr("inputMode");
    tr("pdf417CodeWords");
    tr("autoSize");
    tr("center");
    tr("field");
    tr("image");
    tr("keepAspectRatio");
    tr("columnsCount");
    tr("useAlternateBackgroundColor");
    tr("printBeforePageHeader");
    tr("maxScalePercent");
    tr("printOnFirstPage");
    tr("printOnLastPage");
    tr("printAlways");
    tr("repeatOnEachRow");
    tr("condition");
    tr("groupFieldName");
    tr("keepGroupTogether");
    tr("endlessHeight");
    tr("extendedHeight");
    tr("isExtendedInDesignMode");
    tr("pageIsTOC");
    tr("setPageSizeToPrinter");
    tr("fillInSecondPass");
    tr("chartTitle");
    tr("chartType");
    tr("drawLegendBorder");
    tr("labelsField");
    tr("xAxisField");
    tr("legendAlign");
    tr("series");
    tr("titleAlign");
    tr("watermark");
    tr("keepTopSpace");
    tr("printable");
    tr("variable");
    tr("replaceCRwithBR");
    tr("hideIfEmpty");
    tr("hideEmptyItems");
    tr("useExternalPainter");
    tr("layoutSpacing");
    tr("printerName");
    tr("fontLetterSpacing");
    tr("hideText");
    tr("option3");
    tr("units");
    tr("geometryLocked");
    tr("printBehavior");
    tr("shiftItems");
    tr("showLegend");
    tr("seriesLineWidth");
    tr("drawPoints");
    tr("removeGap");
    tr("dropPrinterMargins");
    tr("notPrintIfEmpty");
    tr("gridChartLines");
    tr("horizontalAxisOnTop");
    tr("mixWithPriorPage");
    tr("shadow");
    tr("borderStyle");
}

void QObjectPropertyModel::clearObjectsList() { m_objects.clear(); }

QObjectPropertyModel::QObjectPropertyModel(QObject* parent /*=0*/):
    QAbstractItemModel(parent),
    m_rootNode(0),
    m_object(0),
    m_dataChanging(false),
    m_subclassesAsLevel(true),
    m_validator(0),
    m_translateProperties(true)
{
}

QObjectPropertyModel::~QObjectPropertyModel() { delete m_rootNode; }

void QObjectPropertyModel::initModel()
{
    beginResetModel();
    delete m_rootNode;
    m_rootNode = 0;
    if (m_object) {
        connect(m_object, SIGNAL(destroyed(QObject*)), this, SLOT(slotObjectDestroyed(QObject*)));
        m_rootNode = new ObjectPropItem(0, 0, "root", "root", QVariant(), 0);
        m_rootNode->setModel(this);
        foreach (QObject* item, m_objects)
            connect(item, SIGNAL(destroyed(QObject*)), this, SLOT(slotObjectDestroyed(QObject*)));
        addObjectProperties(m_object->metaObject(), m_object, &m_objects);
    }
    endResetModel();
}

void QObjectPropertyModel::setObject(QObject* object)
{
    m_objects.clear();
    if (m_object != object) {
        submit();
        m_object = object;
        initModel();
    }
}

void QObjectPropertyModel::setMultiObjects(QList<QObject*>* list)
{
    m_objects.clear();
    submit();

    if (list->isEmpty()) {
        return;
    }

    if (!list->contains(m_object)) {
        m_object = list->at(0);
        list->removeAt(0);
    } else {
        list->removeOne(m_object);
    }

    foreach (QObject* item, *list)
        m_objects.append(item);
    // initModel();
}

void QObjectPropertyModel::slotObjectDestroyed(QObject* obj)
{
    m_objects.removeOne(obj);
    if (m_object == obj) {
        m_object = 0;
        initModel();
    }
}

void QObjectPropertyModel::slotPropertyChanged(const QString& propertyName,
                                               const QVariant& oldValue, const QVariant& newValue)
{
    Q_UNUSED(oldValue);
    Q_UNUSED(newValue);
    if (m_object)
        updateProperty(propertyName);
}

void QObjectPropertyModel::slotPropertyObjectNameChanged(const QString& oldName,
                                                         const QString& newName)
{
    Q_UNUSED(oldName)
    Q_UNUSED(newName)
    if (m_object)
        updateProperty("objectName");
}

int QObjectPropertyModel::columnCount(const QModelIndex& /*parent*/) const { return 2; }

QVariant QObjectPropertyModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
        if (section == 0)
            return tr("Property Name");
        else
            return tr("Property value");
    } else
        return QVariant();
}

ObjectPropItem* QObjectPropertyModel::nodeFromIndex(const QModelIndex& index) const
{
    if (index.isValid()) {
        return static_cast<ObjectPropItem*>(index.internalPointer());
    } else
        return m_rootNode;
}

void QObjectPropertyModel::updateProperty(const QString& propertyName)
{
    if (!m_dataChanging && m_rootNode) {
        ObjectPropItem* propItem = m_rootNode->findPropertyItem(propertyName);
        if (propItem)
            propItem->updatePropertyValue();
    }
}

void QObjectPropertyModel::setSubclassesAsLevel(bool value) { m_subclassesAsLevel = value; }

int QObjectPropertyModel::rowCount(const QModelIndex& parent) const
{
    if (!m_rootNode)
        return 0;
    ObjectPropItem* parentNode;
    if (parent.isValid())
        parentNode = nodeFromIndex(parent);
    else
        parentNode = m_rootNode;
    return parentNode->childCount();
}

QVariant QObjectPropertyModel::data(const QModelIndex& index, int role) const
{
    ObjectPropItem* node = nodeFromIndex(index);
    switch (role) {
    case Qt::DisplayRole:
        if (!node)
            return QVariant();
        node->setTranslateProperty(isTranslateProperties());
        if (index.column() == 0) {
            return node->displayName();
        } else {
            return node->displayValue();
        }
    case Qt::DecorationRole:
        if (!node)
            return QIcon();
        if (index.column() == 1) {
            return node->iconValue();
        } else
            return QIcon();
    case Qt::UserRole:
        return QVariant::fromValue(node);
    default:
        return QVariant();
    }
}

QModelIndex QObjectPropertyModel::index(int row, int column, const QModelIndex& parent) const
{
    if (!m_rootNode)
        return QModelIndex();

    if (!hasIndex(row, column, parent))
        return QModelIndex();

    ObjectPropItem* parentNode;
    if (parent.isValid())
        parentNode = nodeFromIndex(parent);
    else
        parentNode = m_rootNode;

    ObjectPropItem* childItem = parentNode->child(row);

    if (childItem) {
        QModelIndex modelIndex = createIndex(row, column, childItem);
        if (column == 1) {
            if (childItem->modelIndex() != modelIndex) {
                childItem->setModelIndex(modelIndex);
            }
        }
        return modelIndex;
    } else
        return QModelIndex();
}

QModelIndex QObjectPropertyModel::parent(const QModelIndex& child) const
{
    if (!child.isValid())
        return QModelIndex();

    ObjectPropItem* childNode = nodeFromIndex(child);
    if (!childNode)
        return QModelIndex();

    ObjectPropItem* parentNode = childNode->parent();
    if ((parentNode == m_rootNode) || (!parentNode))
        return QModelIndex();

    return createIndex(parentNode->row(), 0, parentNode);
}

Qt::ItemFlags QObjectPropertyModel::flags(const QModelIndex& index) const
{
    if ((index.column() == 1) && (!nodeFromIndex(index)->isValueReadonly()))
        return Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable;
    else
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

CreatePropItem QObjectPropertyModel::propertyItemCreator(QMetaProperty prop)
{
    CreatePropItem creator = 0;
    creator = ObjectPropFactory::instance().objectCreator(
        APropIdent(prop.name(), prop.enclosingMetaObject()->className()));
    if (!creator) {
        if (prop.isFlagType()) {
            creator = ObjectPropFactory::instance().objectCreator(APropIdent("flags", ""));
            if (creator) {
                return creator;
            } else {
                qDebug() << "flags prop editor not found";
                return 0;
            }
        }
        if (prop.isEnumType()) {
            creator = ObjectPropFactory::instance().objectCreator(APropIdent("enum", ""));
            if (creator) {
                return creator;
            } else {
                qDebug() << "enum prop editor not found";
                return 0;
            }
        }
        creator = ObjectPropFactory::instance().objectCreator(APropIdent(prop.typeName(), ""));
        if (!creator) {
            qDebug() << "Editor for propperty name = \"" << prop.name() << "\" & property type =\""
                     << prop.typeName() << "\" not found!";
        }
    }
    return creator;
}

ObjectPropItem* QObjectPropertyModel::createPropertyItem(QMetaProperty prop, QObject* object,
                                                         ObjectPropItem::ObjectsList* objects,
                                                         ObjectPropItem* parent)
{
    ObjectPropItem* propertyItem = 0;
    CreatePropItem creator = propertyItemCreator(prop);

    if (creator) {
        propertyItem = creator(object, objects, QString(prop.name()), QString(tr(prop.name())),
                               object->property(prop.name()), parent,
                               !(prop.isWritable() && prop.isDesignable()));
    } else {
        propertyItem = new ObjectPropItem(0, 0, QString(prop.name()), QString(tr(prop.name())),
                                          object->property(prop.name()), parent);
    }
    return propertyItem;
}

bool QObjectPropertyModel::isTranslateProperties() const { return m_translateProperties; }

void QObjectPropertyModel::setTranslateProperties(bool translateProperties)
{
    m_translateProperties = translateProperties;
}
ValidatorIntf* QObjectPropertyModel::validator() const { return m_validator; }

void QObjectPropertyModel::setValidator(ValidatorIntf* validator) { m_validator = validator; }

void QObjectPropertyModel::addObjectProperties(const QMetaObject* metaObject, QObject* object,
                                               ObjectPropItem::ObjectsList* objects, int level)
{
    if (metaObject->propertyCount() > metaObject->propertyOffset()) {
        ObjectPropItem* objectNode;
        if (m_subclassesAsLevel) {
            objectNode = new ObjectPropItem(0, 0, metaObject->className(), metaObject->className(),
                                            m_rootNode, true);
            m_rootNode->appendItem(objectNode);
        } else {
            objectNode = m_rootNode;
        }

        for (int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); i++) {
            if (metaObject->property(i).isDesignable()) {
                ObjectPropItem* prop
                    = createPropertyItem(metaObject->property(i), object, objects, objectNode);
                objectNode->appendItem(prop);
            }
        }
        if (m_subclassesAsLevel) {
            objectNode->setColorIndex(level);
            objectNode->sortItem();
            level++;
        }
    }

    if (metaObject->superClass())
        addObjectProperties(metaObject->superClass(), object, objects, level);
    m_rootNode->sortItem();
}

bool QObjectPropertyModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (index.isValid() && role == Qt::EditRole) {
        m_dataChanging = true;
        ObjectPropItem* propItem = nodeFromIndex(index);
        if (propItem->propertyValue() != value) {
            QString msg;
            if (validator()
                && !validator()->validate(propItem->propertyName(), value.toString(), m_object,
                                          msg)) {
                QMessageBox::information(0, tr("Warning"), msg);
                return true;
            }
            QVariant oldValue = propItem->propertyValue();
            propItem->setPropertyValue(value);
            emit dataChanged(index, index);
            emit objectPropetyChanged(propItem->propertyName(), oldValue,
                                      propItem->propertyValue());
        }
        m_dataChanging = false;
        return true;
    }
    return false;
}

void QObjectPropertyModel::itemDataChanged(const QModelIndex& index)
{
    emit dataChanged(index, index);
}

} // namespace LimeReport