// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#include "fakemetaobject.h"
#include <QCryptographicHash>

using namespace LanguageUtils;

static QByteArrayView asData(const void *mem, size_t len)
{
    return QByteArrayView(reinterpret_cast<const char *>(mem), len);
}

static void addData(QCryptographicHash &hash, int x)
{
    hash.addData(asData(&x, sizeof(int)));
}

static void addData(QCryptographicHash &hash, const QString &x)
{
    hash.addData(asData(x.constData(), x.size() * sizeof(QChar)));
}

FakeMetaEnum::FakeMetaEnum()
{}

FakeMetaEnum::FakeMetaEnum(const QString &name)
    : m_name(name)
{}

bool FakeMetaEnum::isValid() const
{ return !m_name.isEmpty(); }

QString FakeMetaEnum::name() const
{ return m_name; }

void FakeMetaEnum::setName(const QString &name)
{ m_name = name; }

void FakeMetaEnum::addKey(const QString &key)
{ m_keys.append(key); }

QString FakeMetaEnum::key(int index) const
{ return m_keys.at(index); }

int FakeMetaEnum::keyCount() const
{ return m_keys.size(); }

QStringList FakeMetaEnum::keys() const
{ return m_keys; }

bool FakeMetaEnum::hasKey(const QString &key) const
{ return m_keys.contains(key); }

void FakeMetaEnum::addToHash(QCryptographicHash &hash) const
{
    addData(hash, m_name.size());
    addData(hash, m_name);
    addData(hash, m_keys.size());
    for (const QString &key : std::as_const(m_keys)) {
        addData(hash, key.size());
        addData(hash, key);
    }
}

QString FakeMetaEnum::describe(int baseIndent) const
{
    QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent);
    QString res = QLatin1String("Enum ");
    res += name();
    res += QLatin1String(": [");
    for (int i = 0; i < keyCount(); ++i) {
        res += newLine;
        res += QLatin1String("  ");
        res += key(i);
    }
    res += newLine;
    res += QLatin1Char(']');
    return res;
}

QString FakeMetaEnum::toString() const
{
    return describe();
}

FakeMetaMethod::FakeMetaMethod(const QString &name, const QString &returnType)
    : m_name(name)
    , m_returnType(returnType)
    , m_methodTy(FakeMetaMethod::Method)
    , m_methodAccess(FakeMetaMethod::Public)
    , m_revision(0)
{}

FakeMetaMethod::FakeMetaMethod()
    : m_methodTy(FakeMetaMethod::Method)
    , m_methodAccess(FakeMetaMethod::Public)
    , m_revision(0)
{}

QString FakeMetaMethod::methodName() const
{ return m_name; }

void FakeMetaMethod::setMethodName(const QString &name)
{ m_name = name; }

void FakeMetaMethod::setReturnType(const QString &type)
{ m_returnType = type; }

QStringList FakeMetaMethod::parameterNames() const
{ return m_paramNames; }

QStringList FakeMetaMethod::parameterTypes() const
{ return m_paramTypes; }

void FakeMetaMethod::addParameter(const QString &name, const QString &type)
{ m_paramNames.append(name); m_paramTypes.append(type); }

int FakeMetaMethod::methodType() const
{ return m_methodTy; }

void FakeMetaMethod::setMethodType(int methodType)
{ m_methodTy = methodType; }

int FakeMetaMethod::access() const
{ return m_methodAccess; }

int FakeMetaMethod::revision() const
{ return m_revision; }

void FakeMetaMethod::setRevision(int r)
{ m_revision = r; }

void FakeMetaMethod::addToHash(QCryptographicHash &hash) const
{
    addData(hash, m_name.size());
    addData(hash, m_name);
    addData(hash, m_methodAccess);
    addData(hash, m_methodTy);
    addData(hash, m_revision);
    addData(hash, m_paramNames.size());
    for (const QString &pName : std::as_const(m_paramNames)) {
        addData(hash, pName.size());
        addData(hash, pName);
    }
    addData(hash, m_paramTypes.size());
    for (const QString &pType : std::as_const(m_paramTypes)) {
        addData(hash, pType.size());
        addData(hash, pType);
    }
    addData(hash, m_returnType.size());
    addData(hash, m_returnType);
}

QString FakeMetaMethod::describe(int baseIndent) const
{
    QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent);
    QString res = QLatin1String("Method {");
    res += newLine;
    res += QLatin1String("  methodName:");
    res += methodName();
    res += newLine;
    res += QLatin1String("  methodType:");
    res += QString::number(methodType());
    res += newLine;
    res += QLatin1String("  parameterNames:[");
    for (const QString &pName : parameterNames()) {
        res += newLine;
        res += QLatin1String("    ");
        res += pName;
    }
    res += QLatin1Char(']');
    res += newLine;
    res += QLatin1String("  parameterTypes:[");
    for (const QString &pType : parameterTypes()) {
        res += newLine;
        res += QLatin1String("    ");
        res += pType;
    }
    res += QLatin1Char(']');
    res += newLine;
    res += QLatin1Char('}');
    return res;
}

QString FakeMetaMethod::toString() const
{
    return describe();
}


FakeMetaProperty::FakeMetaProperty(const QString &name, const QString &type, bool isList,
                                   bool isWritable, bool isPointer, int revision)
    : m_propertyName(name)
    , m_type(type)
    , m_isList(isList)
    , m_isWritable(isWritable)
    , m_isPointer(isPointer)
    , m_revision(revision)
{}

QString FakeMetaProperty::name() const
{ return m_propertyName; }

QString FakeMetaProperty::typeName() const
{ return m_type; }

bool FakeMetaProperty::isList() const
{ return m_isList; }

bool FakeMetaProperty::isWritable() const
{ return m_isWritable; }

bool FakeMetaProperty::isPointer() const
{ return m_isPointer; }

int FakeMetaProperty::revision() const
{ return m_revision; }

void FakeMetaProperty::addToHash(QCryptographicHash &hash) const
{
    addData(hash, m_propertyName.size());
    addData(hash, m_propertyName);
    addData(hash, m_revision);
    int flags = (m_isList ? (1 << 0) : 0)
            + (m_isPointer ? (1 << 1) : 0)
            + (m_isWritable ? (1 << 2) : 0);
    addData(hash, flags);
    addData(hash, m_type.size());
    addData(hash, m_type);
}

QString FakeMetaProperty::describe(int baseIndent) const
{
    auto boolStr = [] (bool v) { return v ? QLatin1String("true") : QLatin1String("false"); };
    QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent);
    QString res = QLatin1String("Property  {");
    res += newLine;
    res += QLatin1String("  name:");
    res += name();
    res += newLine;
    res += QLatin1String("  typeName:");
    res += typeName();
    res += newLine;
    res += QLatin1String("  typeName:");
    res += QString::number(revision());
    res += newLine;
    res += QLatin1String("  isList:");
    res += boolStr(isList());
    res += newLine;
    res += QLatin1String("  isPointer:");
    res += boolStr(isPointer());
    res += newLine;
    res += QLatin1String("  isWritable:");
    res += boolStr(isWritable());
    res += newLine;
    res += QLatin1Char('}');
    return res;
}

QString FakeMetaProperty::toString() const
{
    return describe();
}


FakeMetaObject::FakeMetaObject() : m_isSingleton(false), m_isCreatable(true), m_isComposite(false)
{
}

QString FakeMetaObject::className() const
{ return m_className; }
void FakeMetaObject::setClassName(const QString &name)
{ m_className = name; }

QString FakeMetaObject::filePath() const
{ return m_filePath; }
void FakeMetaObject::setFilePath(const QString &path)
{ m_filePath = path; }

void FakeMetaObject::addExport(const QString &name, const QString &package, ComponentVersion version)
{
    Export exp;
    exp.type = name;
    exp.package = package;
    exp.version = version;
    m_exports.append(exp);
}

void FakeMetaObject::setExportMetaObjectRevision(int exportIndex, int metaObjectRevision)
{
    m_exports[exportIndex].metaObjectRevision = metaObjectRevision;
}

const QList<FakeMetaObject::Export> FakeMetaObject::exports() const
{ return m_exports; }
FakeMetaObject::Export FakeMetaObject::exportInPackage(const QString &package) const
{
    for (const Export &exp : m_exports) {
        if (exp.package == package)
            return exp;
    }
    return Export();
}

void FakeMetaObject::setSuperclassName(const QString &superclass)
{ m_superName = superclass; }
QString FakeMetaObject::superclassName() const
{ return m_superName; }

void FakeMetaObject::addEnum(const FakeMetaEnum &fakeEnum)
{ m_enumNameToIndex.insert(fakeEnum.name(), m_enums.size()); m_enums.append(fakeEnum); }
int FakeMetaObject::enumeratorCount() const
{ return m_enums.size(); }
int FakeMetaObject::enumeratorOffset() const
{ return 0; }
FakeMetaEnum FakeMetaObject::enumerator(int index) const
{ return m_enums.at(index); }
int FakeMetaObject::enumeratorIndex(const QString &name) const
{ return m_enumNameToIndex.value(name, -1); }

void FakeMetaObject::addProperty(const FakeMetaProperty &property)
{ m_propNameToIdx.insert(property.name(), m_props.size()); m_props.append(property); }
int FakeMetaObject::propertyCount() const
{ return m_props.size(); }
int FakeMetaObject::propertyOffset() const
{ return 0; }
FakeMetaProperty FakeMetaObject::property(int index) const
{ return m_props.at(index); }
int FakeMetaObject::propertyIndex(const QString &name) const
{ return m_propNameToIdx.value(name, -1); }

void FakeMetaObject::addMethod(const FakeMetaMethod &method)
{ m_methods.append(method); }
int FakeMetaObject::methodCount() const
{ return m_methods.size(); }
int FakeMetaObject::methodOffset() const
{ return 0; }
FakeMetaMethod FakeMetaObject::method(int index) const
{ return m_methods.at(index); }
int FakeMetaObject::methodIndex(const QString &name) const //If performances becomes an issue, just use a nameToIdx hash
{
    for (int i=0; i<m_methods.count(); i++)
        if (m_methods[i].methodName() == name)
            return i;
    return -1;
}

QString FakeMetaObject::defaultPropertyName() const
{ return m_defaultPropertyName; }
void FakeMetaObject::setDefaultPropertyName(const QString &defaultPropertyName)
{ m_defaultPropertyName = defaultPropertyName; }

QString FakeMetaObject::attachedTypeName() const
{ return m_attachedTypeName; }
void FakeMetaObject::setAttachedTypeName(const QString &name)
{ m_attachedTypeName = name; }

QString FakeMetaObject::extensionTypeName() const
{ return m_extensionTypeName; }
void FakeMetaObject::setExtensionTypeName(const QString &name)
{ m_extensionTypeName = name; }

QByteArray FakeMetaObject::calculateFingerprint() const
{
    QCryptographicHash hash(QCryptographicHash::Sha1);
    int len = m_className.size();
    addData(hash, len);
    addData(hash, m_className);
    len = m_attachedTypeName.size();
    addData(hash, len);
    addData(hash, m_attachedTypeName);
    len = m_defaultPropertyName.size();
    addData(hash, len);
    addData(hash, m_defaultPropertyName);
    len = m_enumNameToIndex.size();
    addData(hash, len);
    {
        QStringList keys(m_enumNameToIndex.keys());
        keys.sort();
        for (const QString &key : std::as_const(keys)) {
            len = key.size();
            addData(hash, len);
            addData(hash, key);
            int value = m_enumNameToIndex.value(key);
            addData(hash, value);
            m_enums.at(value).addToHash(hash);
        }
    }
    len = m_exports.size();
    addData(hash, len);
    for (const Export &e : std::as_const(m_exports))
        e.addToHash(hash); // normalize order?
    len = m_exports.size();
    addData(hash, len);
    for (const FakeMetaMethod &m : std::as_const(m_methods))
        m.addToHash(hash); // normalize order?
    {
        QStringList keys(m_propNameToIdx.keys());
        keys.sort();
        for (const QString &key : std::as_const(keys)) {
            len = key.size();
            addData(hash, len);
            addData(hash, key);
            int value = m_propNameToIdx.value(key);
            addData(hash, value);
            m_props.at(value).addToHash(hash);
        }
    }
    len = m_superName.size();
    addData(hash, len);
    addData(hash, m_superName);

    QByteArray res = hash.result();
    res.append('F');
    return res;
}

void FakeMetaObject::updateFingerprint()
{
    m_fingerprint = calculateFingerprint();
}

QByteArray FakeMetaObject::fingerprint() const
{
    return m_fingerprint;
}

bool FakeMetaObject::isSingleton() const
{
    return m_isSingleton;
}

bool FakeMetaObject::isCreatable() const
{
    return m_isCreatable;
}

bool FakeMetaObject::isComposite() const
{
    return m_isComposite;
}

void FakeMetaObject::setIsSingleton(bool value)
{
    m_isSingleton = value;
}

void FakeMetaObject::setIsCreatable(bool value)
{
    m_isCreatable = value;
}

void FakeMetaObject::setIsComposite(bool value)
{
    m_isSingleton = value;
}

QString FakeMetaObject::toString() const
{
    return describe();
}

QString FakeMetaObject::describe(bool printDetails, int baseIndent) const
{
    QString res = QString::fromLatin1("FakeMetaObject@%1")
         .arg((quintptr)(void *)this, 0, 16);
    if (!printDetails)
        return res;
    auto boolStr = [] (bool v) { return v ? QLatin1String("true") : QLatin1String("false"); };
    QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent);
    res += QLatin1Char('{');
    res += newLine;
    res += QLatin1String("className:");
    res += className();
    res += newLine;
    res += QLatin1String("superClassName:");
    res += superclassName();
    res += newLine;
    res += QLatin1String("isSingleton:");
    res += boolStr(isSingleton());
    res += newLine;
    res += QLatin1String("isCreatable:");
    res += boolStr(isCreatable());
    res += newLine;
    res += QLatin1String("isComposite:");
    res += boolStr(isComposite());
    res += newLine;
    res += QLatin1String("defaultPropertyName:");
    res += defaultPropertyName();
    res += newLine;
    res += QLatin1String("attachedTypeName:");
    res += attachedTypeName();
    res += newLine;
    res += QLatin1String("fingerprint:");
    res += QString::fromUtf8(fingerprint());

    res += newLine;
    res += QLatin1String("exports:[");
    for (const Export &e : exports()) {
        res += newLine;
        res += QLatin1String("  ");
        res += e.describe(baseIndent + 2);
    }
    res += QLatin1Char(']');

    res += newLine;
    res += QLatin1String("enums:[");
    for (int iEnum = 0; iEnum < enumeratorCount() ; ++ iEnum) {
        FakeMetaEnum e = enumerator(enumeratorOffset() + iEnum);
        res += newLine;
        res += QLatin1String("  ");
        res += e.describe(baseIndent + 2);
    }
    res += QLatin1Char(']');

    res += newLine;
    res += QLatin1String("properties:[");
    for (int iProp = 0; iProp < propertyCount() ; ++ iProp) {
        FakeMetaProperty prop = property(propertyOffset() + iProp);
        res += newLine;
        res += QLatin1String("  ");
        res += prop.describe(baseIndent + 2);
    }
    res += QLatin1Char(']');
    res += QLatin1String("methods:[");
    for (int iMethod = 0; iMethod < methodOffset() ; ++ iMethod) {
        FakeMetaMethod m = method(methodOffset() + iMethod);
        res += newLine;
        res += QLatin1String("  ");
        m.describe(baseIndent + 2);
    }
    res += QLatin1Char(']');
    res += newLine;
    res += QLatin1Char('}');
    return res;
}

FakeMetaObject::Export::Export()
    : metaObjectRevision(0)
{}
bool FakeMetaObject::Export::isValid() const
{ return version.isValid() || !package.isEmpty() || !type.isEmpty(); }

void FakeMetaObject::Export::addToHash(QCryptographicHash &hash) const
{
    addData(hash, package.size());
    addData(hash, package);
    addData(hash, type.size());
    addData(hash, type);
    version.addToHash(hash);
    addData(hash, metaObjectRevision);
}

QString FakeMetaObject::Export::describe(int baseIndent) const
{
    QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent);
    QString res = QLatin1String("Export {");
    res += newLine;
    res += QLatin1String("  package:");
    res += package;
    res += newLine;
    res += QLatin1String("  type:");
    res += type;
    res += newLine;
    res += QLatin1String("  version:");
    res += version.toString();
    res += newLine;
    res += QLatin1String("  metaObjectRevision:");
    res += QString::number(metaObjectRevision);
    res += newLine;
    res += QLatin1String("  isValid:");
    res += QString::number(isValid());
    res += newLine;
    res += QLatin1Char('}');
    return res;
}

QString FakeMetaObject::Export::toString() const
{
    return describe();
}
