/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtQml module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QV4VALUE_P_H
#define QV4VALUE_P_H

#include <limits.h>

#include <QtCore/QString>
#include "qv4global_p.h"

QT_BEGIN_NAMESPACE

namespace QV4 {

typedef uint Bool;

template <typename T>
struct Returned : private T
{
    static Returned<T> *create(T *t) { return static_cast<Returned<T> *>(t); }
    T *getPointer() { return this; }
    template<typename X>
    static T *getPointer(Returned<X> *x) { return x->getPointer(); }
    template<typename X>
    Returned<X> *as() { return Returned<X>::create(Returned<X>::getPointer(this)); }
    using T::asReturnedValue;
};

struct HeapObject {};

struct Q_QML_PRIVATE_EXPORT Value
{
    /*
        We use two different ways of encoding JS values. One for 32bit and one for 64bit systems.

        In both cases, we 8 bytes for a value and different variant of NaN boxing. A Double NaN (actually -qNaN)
        is indicated by a number that has the top 13 bits set. THe other values are usually set to 0 by the
        processor, and are thus free for us to store other data. We keep pointers in there for managed objects,
        and encode the other types using the free space given to use by the unused bits for NaN values. This also
        works for pointers on 64 bit systems, as they all currently only have 48 bits of addressable memory.

        On 32bit, we store doubles as doubles. All other values, have the high 32bits set to a value that
        will make the number a NaN. The Masks below are used for encoding the other types.

        On 64 bit, we xor Doubles with (0xffff8000 << 32). Thas has the effect that no doubles will get encoded
        with the 13 highest bits all 0. We are now using special values for bits 14-17 to encode our values. These
        can be used, as the highest valid pointer on a 64 bit system is 2^48-1.

        If they are all 0, we have a pointer to a Managed object. If bit 14 is set we have an integer.
        This makes testing for pointers and numbers very fast (we have a number if any of the highest 14 bits is set).

        Bit 15-17 is then used to encode other immediates.
    */


    union {
        quint64 val;
#if QT_POINTER_SIZE == 8
        Managed *m;
        Object *o;
        String *s;
#else
        double dbl;
#endif
        struct {
#if Q_BYTE_ORDER != Q_LITTLE_ENDIAN
            uint tag;
#endif
            union {
                uint uint_32;
                int int_32;
#if QT_POINTER_SIZE == 4
                Managed *m;
                Object *o;
                String *s;
#endif
            };
#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
            uint tag;
#endif
        };
    };

#if QT_POINTER_SIZE == 4
    enum Masks {
        SilentNaNBit           =                  0x00040000,
        NaN_Mask               =                  0x7ff80000,
        NotDouble_Mask         =                  0x7ffa0000,
        Type_Mask              =                  0xffffc000,
        Immediate_Mask         = NotDouble_Mask | 0x00004000 | SilentNaNBit,
        IsNullOrUndefined_Mask = Immediate_Mask |    0x08000,
        Tag_Shift = 32
    };
    enum ValueType {
        Undefined_Type = Immediate_Mask | 0x00000,
        Null_Type      = Immediate_Mask | 0x10000,
        Boolean_Type   = Immediate_Mask | 0x08000,
        Integer_Type   = Immediate_Mask | 0x18000,
        Managed_Type   = NotDouble_Mask | 0x00000 | SilentNaNBit,
        Empty_Type     = NotDouble_Mask | 0x18000 | SilentNaNBit
    };

    enum ImmediateFlags {
        ConvertibleToInt = Immediate_Mask | 0x1
    };

    enum ValueTypeInternal {
        _Null_Type = Null_Type | ConvertibleToInt,
        _Boolean_Type = Boolean_Type | ConvertibleToInt,
        _Integer_Type = Integer_Type | ConvertibleToInt,

    };
#else
    static const quint64 NaNEncodeMask = 0xffff800000000000ll;
    static const quint64 IsInt32Mask  = 0x0002000000000000ll;
    static const quint64 IsDoubleMask = 0xfffc000000000000ll;
    static const quint64 IsNumberMask = IsInt32Mask|IsDoubleMask;
    static const quint64 IsNullOrUndefinedMask = 0x0000800000000000ll;
    static const quint64 IsNullOrBooleanMask = 0x0001000000000000ll;
    static const quint64 IsConvertibleToIntMask = IsInt32Mask|IsNullOrBooleanMask;

    enum Masks {
        NaN_Mask = 0x7ff80000,
        Type_Mask = 0xffff8000,
        IsDouble_Mask = 0xfffc0000,
        Immediate_Mask = 0x00018000,
        IsNullOrUndefined_Mask = 0x00008000,
        IsNullOrBoolean_Mask = 0x00010000,
        Tag_Shift = 32
    };
    enum ValueType {
        Undefined_Type = IsNullOrUndefined_Mask,
        Null_Type = IsNullOrUndefined_Mask|IsNullOrBoolean_Mask,
        Boolean_Type = IsNullOrBoolean_Mask,
        Integer_Type = 0x20000|IsNullOrBoolean_Mask,
        Managed_Type = 0,
        Empty_Type = Undefined_Type | 0x4000
    };
    enum {
        IsDouble_Shift = 64-14,
        IsNumber_Shift = 64-15,
        IsConvertibleToInt_Shift = 64-16,
        IsManaged_Shift = 64-17
    };


    enum ValueTypeInternal {
        _Null_Type = Null_Type,
        _Boolean_Type = Boolean_Type,
        _Integer_Type = Integer_Type
    };
#endif

    inline unsigned type() const {
        return tag & Type_Mask;
    }

    // used internally in property
    inline bool isEmpty() const { return tag == Empty_Type; }

    inline bool isUndefined() const { return tag == Undefined_Type; }
    inline bool isNull() const { return tag == _Null_Type; }
    inline bool isBoolean() const { return tag == _Boolean_Type; }
#if QT_POINTER_SIZE == 8
    inline bool isInteger() const { return (val >> IsNumber_Shift) == 1; }
    inline bool isDouble() const { return (val >> IsDouble_Shift); }
    inline bool isNumber() const { return (val >> IsNumber_Shift); }
    inline bool isManaged() const { return !(val >> IsManaged_Shift); }
    inline bool isNullOrUndefined() const { return ((val >> IsManaged_Shift) & ~2) == 1; }
    inline bool integerCompatible() const { return ((val >> IsConvertibleToInt_Shift) & ~2) == 1; }
    static inline bool integerCompatible(Value a, Value b) {
        return a.integerCompatible() && b.integerCompatible();
    }
    static inline bool bothDouble(Value a, Value b) {
        return a.isDouble() && b.isDouble();
    }
    double doubleValue() const {
        Q_ASSERT(isDouble());
        union {
            quint64 i;
            double d;
        } v;
        v.i = val ^ NaNEncodeMask;
        return v.d;
    }
    void setDouble(double d) {
        union {
            quint64 i;
            double d;
        } v;
        v.d = d;
        val = v.i ^ NaNEncodeMask;
        Q_ASSERT(isDouble());
    }
    bool isNaN() const { return (tag & 0x7fff8000) == 0x00078000; }
#else
    inline bool isInteger() const { return tag == _Integer_Type; }
    inline bool isDouble() const { return (tag & NotDouble_Mask) != NotDouble_Mask; }
    inline bool isNumber() const { return tag == _Integer_Type || (tag & NotDouble_Mask) != NotDouble_Mask; }
    inline bool isManaged() const { return tag == Managed_Type; }
    inline bool isNullOrUndefined() const { return (tag & IsNullOrUndefined_Mask) == Undefined_Type; }
    inline bool integerCompatible() const { return (tag & ConvertibleToInt) == ConvertibleToInt; }
    static inline bool integerCompatible(Value a, Value b) {
        return ((a.tag & b.tag) & ConvertibleToInt) == ConvertibleToInt;
    }
    static inline bool bothDouble(Value a, Value b) {
        return ((a.tag | b.tag) & NotDouble_Mask) != NotDouble_Mask;
    }
    double doubleValue() const { Q_ASSERT(isDouble()); return dbl; }
    void setDouble(double d) { dbl = d; Q_ASSERT(isDouble()); }
    bool isNaN() const { return (tag & QV4::Value::NotDouble_Mask) == QV4::Value::NaN_Mask; }
#endif
    inline bool isString() const;
    inline bool isObject() const;
    inline bool isInt32() {
        if (tag == _Integer_Type)
            return true;
        if (isDouble()) {
            double d = doubleValue();
            int i = (int)d;
            if (i == d) {
                int_32 = i;
                tag = _Integer_Type;
                return true;
            }
        }
        return false;
    }
    double asDouble() const {
        if (tag == _Integer_Type)
            return int_32;
        return doubleValue();
    }

    bool booleanValue() const {
        return int_32;
    }
    int integerValue() const {
        return int_32;
    }

    String *stringValue() const {
        return s;
    }
    Object *objectValue() const {
        return o;
    }
    Managed *managed() const {
        return m;
    }

    quint64 rawValue() const {
        return val;
    }

    static inline Value fromManaged(Managed *o);

    int toUInt16() const;
    inline int toInt32() const;
    inline unsigned int toUInt32() const;

    inline bool toBoolean() const;
    double toInteger() const;
    inline double toNumber() const;
    double toNumberImpl() const;
    QString toQStringNoThrow() const;
    QString toQString() const;
    String *toString(ExecutionEngine *e) const;
    String *toString(ExecutionContext *ctx) const;
    Object *toObject(ExecutionContext *ctx) const;

    inline bool isPrimitive() const;
    inline bool tryIntegerConversion() {
        bool b = integerCompatible();
        if (b)
            tag = _Integer_Type;
        return b;
    }

    inline String *asString() const;
    inline Managed *asManaged() const;
    inline Object *asObject() const;
    inline FunctionObject *asFunctionObject() const;
    inline NumberObject *asNumberObject() const;
    inline StringObject *asStringObject() const;
    inline DateObject *asDateObject() const;
    inline ArrayObject *asArrayObject() const;
    inline ErrorObject *asErrorObject() const;

    template<typename T> inline T *as() const;

    inline uint asArrayIndex() const;
    inline uint asArrayLength(bool *ok) const;

    inline ExecutionEngine *engine() const;

    ReturnedValue asReturnedValue() const { return val; }
    static Value fromReturnedValue(ReturnedValue val) { Value v; v.val = val; return v; }

    // Section 9.12
    bool sameValue(Value other) const;

    inline void mark(ExecutionEngine *e) const;

    Value &operator =(const ScopedValue &v);
    Value &operator=(ReturnedValue v) { val = v; return *this; }
    template<typename T>
    Value &operator=(Returned<T> *t);
    template<typename T>
    Value &operator=(T *t) {
        val = Value::fromManaged(t).val;
        return *this;
    }
    Value &operator=(HeapObject *o) {
        m = reinterpret_cast<Managed *>(o);
        return *this;
    }

    template<typename T>
    Value &operator=(const Scoped<T> &t);
    Value &operator=(const ValueRef v);
    Value &operator=(const Value &v) {
        val = v.val;
        return *this;
    }
    template<typename T>
    inline Returned<T> *as();
};

inline Managed *Value::asManaged() const
{
    if (isManaged())
        return managed();
    return 0;
}

inline String *Value::asString() const
{
    if (isString())
        return stringValue();
    return 0;
}

struct Q_QML_PRIVATE_EXPORT Primitive : public Value
{
    inline static Primitive emptyValue();
    static inline Primitive fromBoolean(bool b);
    static inline Primitive fromInt32(int i);
    inline static Primitive undefinedValue();
    static inline Primitive nullValue();
    static inline Primitive fromDouble(double d);
    static inline Primitive fromUInt32(uint i);

    static double toInteger(double fromNumber);
    static int toInt32(double value);
    static unsigned int toUInt32(double value);

    inline operator ValueRef();
    Value asValue() const { return *this; }
};

inline Primitive Primitive::undefinedValue()
{
    Primitive v;
#if QT_POINTER_SIZE == 8
    v.val = quint64(Undefined_Type) << Tag_Shift;
#else
    v.tag = Undefined_Type;
    v.int_32 = 0;
#endif
    return v;
}

inline Primitive Primitive::emptyValue()
{
    Primitive v;
    v.tag = Value::Empty_Type;
    v.uint_32 = 0;
    return v;
}

inline Value Value::fromManaged(Managed *m)
{
    if (!m)
        return QV4::Primitive::undefinedValue();
    Value v;
#if QT_POINTER_SIZE == 8
    v.m = m;
#else
    v.tag = Managed_Type;
    v.m = m;
#endif
    return v;
}

template <typename T>
struct TypedValue : public Value
{
    template<typename X>
    TypedValue &operator =(X *x) {
        m = x;
#if QT_POINTER_SIZE == 4
        tag = Managed_Type;
#endif
    }
    TypedValue &operator =(T *t);
    TypedValue &operator =(const Scoped<T> &v);
//    TypedValue &operator =(const ManagedRef<T> &v);
    TypedValue &operator =(Returned<T> *t);

    TypedValue &operator =(const TypedValue<T> &t);

    bool operator!() const { return !managed(); }

    operator T *() { return static_cast<T *>(managed()); }
    T *operator->() { return static_cast<T *>(managed()); }
    const T *operator->() const { return static_cast<T *>(managed()); }
    T *getPointer() const { return static_cast<T *>(managed()); }
    Returned<T> *ret() const;

    void mark(ExecutionEngine *e) { if (managed()) managed()->mark(e); }
};
typedef TypedValue<String> StringValue;


struct Encode {
    static ReturnedValue undefined() {
        return quint64(Value::Undefined_Type) << Value::Tag_Shift;
    }
    static ReturnedValue null() {
        return quint64(Value::_Null_Type) << Value::Tag_Shift;
    }

    Encode(bool b) {
        val = (quint64(Value::_Boolean_Type) << Value::Tag_Shift) | (uint)b;
    }
    Encode(double d) {
        Value v;
        v.setDouble(d);
        val = v.val;
    }
    Encode(int i) {
        val = (quint64(Value::_Integer_Type) << Value::Tag_Shift) | (uint)i;
    }
    Encode(uint i) {
        if (i <= INT_MAX) {
            val = (quint64(Value::_Integer_Type) << Value::Tag_Shift) | i;
        } else {
            Value v;
            v.setDouble(i);
            val = v.val;
        }
    }
    Encode(ReturnedValue v) {
        val = v;
    }

    template<typename T>
    Encode(Returned<T> *t) {
        val = t->getPointer()->asReturnedValue();
    }

    operator ReturnedValue() const {
        return val;
    }
    quint64 val;
private:
    Encode(void *);
};

struct ValueRef {
    ValueRef(const ScopedValue &v);
    template <typename T>
    ValueRef(const Scoped<T> &v);
    ValueRef(const PersistentValue &v);
    ValueRef(PersistentValuePrivate *p);
    ValueRef(Value &v) { ptr = &v; }
    // Important: Do NOT add a copy constructor to this class
    // adding a copy constructor actually changes the calling convention, ie.
    // is not even binary compatible. Adding it would break assumptions made
    // in the jit'ed code.
    ValueRef &operator=(const ScopedValue &o);
    ValueRef &operator=(const Value &v)
    { *ptr = v; return *this; }
    ValueRef &operator=(const ReturnedValue &v) {
        ptr->val = v;
        return *this;
    }
    template <typename T>
    ValueRef &operator=(Returned<T> *v) {
        ptr->val = v->asReturnedValue();
        return *this;
    }

    operator const Value *() const {
        return ptr;
    }
    const Value *operator->() const {
        return ptr;
    }

    operator Value *() {
        return ptr;
    }
    Value *operator->() {
        return ptr;
    }

    static ValueRef fromRawValue(Value *v) {
        return ValueRef(v);
    }
    static const ValueRef fromRawValue(const Value *v) {
        return ValueRef(const_cast<Value *>(v));
    }

    ReturnedValue asReturnedValue() const { return ptr->val; }

    // ### get rid of this one!
    ValueRef(Value *v) { ptr = reinterpret_cast<Value *>(v); }
private:
    Value *ptr;
};


template<typename T>
T *value_cast(const Value &v)
{
    return v.as<T>();
}

template<typename T>
ReturnedValue value_convert(ExecutionEngine *e, const Value &v);



}

QT_END_NAMESPACE

#endif // QV4VALUE_DEF_P_H