/*
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <limits>

#include "cobalt/base/polymorphic_downcast.h"
#include "cobalt/script/javascript_engine.h"
#include "cobalt/script/javascriptcore/conversion_helpers.h"
#include "cobalt/script/javascriptcore/jsc_global_environment.h"
#include "cobalt/script/javascriptcore/jsc_global_object.h"
#include "cobalt/script/testing/mock_exception_state.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/Source/JavaScriptCore/config.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/JSFunction.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/JSString.h"
#include "third_party/WebKit/Source/JavaScriptCore/runtime/JSValue.h"
#include "third_party/WebKit/Source/WTF/wtf/text/WTFString.h"

using testing::_;

namespace cobalt {
namespace script {
namespace javascriptcore {

namespace {

template <int kNumber>
JSC::EncodedJSValue returnNumberFunction(JSC::ExecState* exec) {
  return JSC::JSValue::encode(JSC::jsNumber(kNumber));
}

template <typename T>
class NumericConversionTest : public ::testing::Test {
 public:
  NumericConversionTest()
      : engine_(JavaScriptEngine::CreateEngine()),
        global_environment_(engine_->CreateGlobalEnvironment()),
        jsc_global_object_(NULL),
        exec_state_(NULL) {
    global_environment_->CreateGlobalObject();
    jsc_global_object_ = base::polymorphic_downcast<JSCGlobalEnvironment*>(
                             global_environment_.get())
                             ->global_object();
    exec_state_ = jsc_global_object_->globalExec();
  }

  void AddFunction(JSC::JSObject* object, const char* name,
                   JSC::NativeFunction function) {
    int num_arguments = 0;
    JSC::Identifier identifier(jsc_global_object_->globalExec(), name);
    object->putDirect(jsc_global_object_->globalData(), identifier,
                      JSC::JSFunction::create(jsc_global_object_->globalExec(),
                                              jsc_global_object_, num_arguments,
                                              identifier.string(), function));
  }

  const scoped_ptr<JavaScriptEngine> engine_;
  const scoped_refptr<GlobalEnvironment> global_environment_;
  JSCGlobalObject* jsc_global_object_;
  JSC::ExecState* exec_state_;
  testing::MockExceptionState exception_state_;
};

template <typename T>
class IntegerConversionTest : public NumericConversionTest<T> {};

template <typename T>
class FloatingPointConversionTest : public NumericConversionTest<T> {};

typedef ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
                         double> NumericTypes;
typedef ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t>
    IntegerTypes;
typedef ::testing::Types<double> FloatingPointTypes;
TYPED_TEST_CASE(NumericConversionTest, NumericTypes);
TYPED_TEST_CASE(IntegerConversionTest, IntegerTypes);
TYPED_TEST_CASE(FloatingPointConversionTest, FloatingPointTypes);

template <class T>
T JSValueToNumber(JSC::ExecState* exec_state, JSC::JSValue js_value,
                  int conversion_flags, ExceptionState* exception_state) {
  T value;
  FromJSValue(exec_state, js_value, conversion_flags, exception_state, &value);
  return value;
}

}  // namespace

// Conversion between a JavaScript value and an IDL integer type is described
// here:
//     https://www.w3.org/TR/WebIDL/#es-byte
//     https://www.w3.org/TR/WebIDL/#es-octet
//     https://www.w3.org/TR/WebIDL/#es-short
//     https://www.w3.org/TR/WebIDL/#es-unsigned-short
//     https://www.w3.org/TR/WebIDL/#es-long
//     https://www.w3.org/TR/WebIDL/#es-unsigned-long
//     https://www.w3.org/TR/WebIDL/#es-double
// The first step in each of these algorithms is the ToNumber operation:
//     http://es5.github.io/#x9.3
// ToNumber describes how various non-numeric types should convert to a
// number.

// ToNumber: http://es5.github.io/#x9.3
TYPED_TEST(NumericConversionTest, BooleanConversion) {
  EXPECT_EQ(1, JSValueToNumber<TypeParam>(
                   this->exec_state_, JSC::jsBoolean(true), kNoConversionFlags,
                   &this->exception_state_));
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                   this->exec_state_, JSC::jsBoolean(false), kNoConversionFlags,
                   &this->exception_state_));
}

// ToNumber applied to the String Type: http://es5.github.io/#x9.3.1
TYPED_TEST(NumericConversionTest, StringConversion) {
  JSC::ExecState* exec = this->jsc_global_object_->globalExec();
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                   this->exec_state_, JSC::jsString(this->exec_state_, ""),
                   kNoConversionFlags, &this->exception_state_));
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                   this->exec_state_, JSC::jsString(this->exec_state_, "    "),
                   kNoConversionFlags, &this->exception_state_));

  // Integer types convert NaN to 0, and float types throw a TypeError.
  if (std::numeric_limits<TypeParam>::is_integer) {
    EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                     this->exec_state_,
                     JSC::jsString(this->exec_state_, "not_a_number"),
                     kNoConversionFlags, &this->exception_state_));
  }

  EXPECT_EQ(32, JSValueToNumber<TypeParam>(
                    this->exec_state_, JSC::jsString(this->exec_state_, "32"),
                    kNoConversionFlags, &this->exception_state_));
  EXPECT_EQ(32, JSValueToNumber<TypeParam>(
                    this->exec_state_, JSC::jsString(this->exec_state_, "0x20"),
                    kNoConversionFlags, &this->exception_state_));

  if (!std::numeric_limits<TypeParam>::is_integer) {
    EXPECT_EQ(54.34,
              JSValueToNumber<TypeParam>(
                  this->exec_state_, JSC::jsString(this->exec_state_, "54.34"),
                  kNoConversionFlags, &this->exception_state_));
  }
}

// Described in the integer type conversion algorithms:
//     Set x to sign(x)*floor(abs(x))
// Also in ToUint16, ToInt32, and ToUInt64:
//     3. Let posInt be sign(number) * floor(abs(number))
TYPED_TEST(IntegerConversionTest, FloatingPointToIntegerConversion) {
  EXPECT_EQ(5, JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNumber(5.1),
                                          kNoConversionFlags,
                                          &this->exception_state_));
  if (std::numeric_limits<TypeParam>::is_signed) {
    EXPECT_EQ(-5, JSValueToNumber<TypeParam>(
                      this->exec_state_, JSC::jsNumber(-5.1),
                      kNoConversionFlags, &this->exception_state_));
  }
}

// http://es5.github.io/#x9.3
TYPED_TEST(IntegerConversionTest, OtherConversions) {
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNull(),
                                          kNoConversionFlags,
                                          &this->exception_state_));

  const double kInfinity = std::numeric_limits<double>::infinity();
  const double kNegativeInfinity = -std::numeric_limits<double>::infinity();
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsUndefined(),
                                          kNoConversionFlags,
                                          &this->exception_state_));
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                   this->exec_state_, JSC::jsNumber(kInfinity),
                   kNoConversionFlags, &this->exception_state_));
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                   this->exec_state_, JSC::jsNumber(kNegativeInfinity),
                   kNoConversionFlags, &this->exception_state_));
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNaN(),
                                          kNoConversionFlags,
                                          &this->exception_state_));
}

// http://es5.github.io/#x9.3
TYPED_TEST(FloatingPointConversionTest, OtherConversions) {
  EXPECT_EQ(0, JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNull(),
                                          kNoConversionFlags,
                                          &this->exception_state_));

  // Check that unrestricted types convert back as expected
  const double kInfinity = std::numeric_limits<double>::infinity();
  const double kNegativeInfinity = -std::numeric_limits<double>::infinity();

  // Unrestricted non-finite floating point conversions
  EXPECT_EQ(kInfinity, JSValueToNumber<TypeParam>(
                           this->exec_state_, JSC::jsNumber(kInfinity),
                           kNoConversionFlags, &this->exception_state_));
  EXPECT_EQ(kNegativeInfinity,
            JSValueToNumber<TypeParam>(
                this->exec_state_, JSC::jsNumber(kNegativeInfinity),
                kNoConversionFlags, &this->exception_state_));
  EXPECT_TRUE(isnan(JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNaN(),
                                               kNoConversionFlags,
                                               &this->exception_state_)));

  // Restricted non-finite floating point conversions. These should throw a
  // TypeError.
  EXPECT_CALL(this->exception_state_, SetSimpleExceptionVA(kNotFinite, _))
      .Times(3);
  JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNumber(kInfinity),
                             kConversionFlagRestricted,
                             &this->exception_state_);
  JSValueToNumber<TypeParam>(
      this->exec_state_, JSC::jsNumber(kNegativeInfinity),
      kConversionFlagRestricted, &this->exception_state_);
  JSValueToNumber<TypeParam>(this->exec_state_, JSC::jsNaN(),
                             kConversionFlagRestricted,
                             &this->exception_state_);
}

// ToNumber (http://es5.github.io/#x9.3) calls the ToPrimitive operation:
//     http://es5.github.io/#x9.1
// ToPrimitive calls the [[DefaultValue]] method of the object:
//     http://es5.github.io/#x8.12.8
TYPED_TEST(NumericConversionTest, ObjectConversion) {
  JSC::JSLockHolder lock(this->jsc_global_object_->globalData());
  JSC::Structure* structure =
      JSC::createEmptyObjectStructure(this->jsc_global_object_->globalData(),
                                      this->jsc_global_object_, JSC::jsNull());
  {
    JSC::JSObject* object =
        JSC::constructEmptyObject(this->exec_state_, structure);
    this->AddFunction(object, "valueOf", &(returnNumberFunction<5>));
    EXPECT_EQ(
        5, JSValueToNumber<TypeParam>(this->jsc_global_object_->globalExec(),
                                      JSC::JSValue(object), kNoConversionFlags,
                                      &this->exception_state_));
  }
  {
    JSC::JSObject* object =
        JSC::constructEmptyObject(this->exec_state_, structure);
    // The conversion algorithm uses the value of toString() if it is
    // a primitive value, which is not necessarily a string.
    this->AddFunction(object, "toString", &(returnNumberFunction<5>));
    EXPECT_EQ(5, JSValueToNumber<TypeParam>(
                     this->exec_state_, JSC::JSValue(object),
                     kNoConversionFlags, &this->exception_state_));
  }
  {
    JSC::JSObject* object =
        JSC::constructEmptyObject(this->exec_state_, structure);
    EXPECT_EQ(0, JSValueToNumber<TypeParam>(
                     this->exec_state_, JSC::JSValue(object),
                     kNoConversionFlags, &this->exception_state_));
  }
}

}  // namespace javascriptcore
}  // namespace script
}  // namespace cobalt