// Copyright 2016 The Cobalt Authors. 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 <algorithm>
#include <memory>
#include <vector>

#include "base/json/json_reader.h"
#include "base/run_loop.h"
#include "cobalt/dom/document.h"
#include "cobalt/dom/testing/stub_window.h"
#include "cobalt/script/global_environment.h"
#include "cobalt/script/javascript_engine.h"
#include "cobalt/webdriver/script_executor.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using ::testing::_;
using ::testing::DefaultValue;
using ::testing::Return;

namespace cobalt {
namespace webdriver {
namespace {

class MockElementMapping : public ElementMapping {
 public:
  MOCK_METHOD1(ElementToId,
               protocol::ElementId(const scoped_refptr<dom::Element>&));
  MOCK_METHOD1(IdToElement,
               scoped_refptr<dom::Element>(const protocol::ElementId& id));
};

class MockScriptExecutorResult : public ScriptExecutorResult::ResultHandler {
 public:
  MOCK_METHOD1(OnResult, void(const std::string&));
  MOCK_METHOD0(OnTimeout, void());
};

class JSONScriptExecutorResult : public ScriptExecutorResult::ResultHandler {
 public:
  void OnResult(const std::string& result) {
    json_result_ = base::JSONReader::Read(result.c_str());
  }
  void OnTimeout() { NOTREACHED(); }
  base::Value* json_result() { return json_result_.get(); }

 private:
  std::unique_ptr<base::Value> json_result_;
};

class ScriptExecutorTest : public ::testing::Test {
 protected:
  void SetUp() override {
    stub_window_.reset(new dom::testing::StubWindow());
    script_executor_ =
        ScriptExecutor::Create(&element_mapping_, global_environment());

    ON_CALL(element_mapping_, IdToElement(_))
        .WillByDefault(Return(scoped_refptr<dom::Element>()));
    ON_CALL(element_mapping_, ElementToId(_))
        .WillByDefault(Return(protocol::ElementId("bad-id")));
  }

  scoped_refptr<dom::Window> window() { return stub_window_->window(); }
  scoped_refptr<script::GlobalEnvironment> global_environment() {
    return stub_window_->global_environment();
  }

 protected:
  std::unique_ptr<dom::testing::StubWindow> stub_window_;
  MockElementMapping element_mapping_;
  scoped_refptr<ScriptExecutor> script_executor_;
};

}  // namespace

TEST_F(ScriptExecutorTest, CreateSyncScript) {
  auto gc_prevented_params =
      ScriptExecutorParams::Create(global_environment(), "return 5;", "[]");
  ASSERT_TRUE(gc_prevented_params.params);
  EXPECT_NE(
      reinterpret_cast<intptr_t>(gc_prevented_params.params->function_object()),
      NULL);
  EXPECT_STREQ(gc_prevented_params.params->json_args().c_str(), "[]");
  EXPECT_EQ(gc_prevented_params.params->async_timeout(), base::nullopt);
}

TEST_F(ScriptExecutorTest, CreateAsyncScript) {
  auto gc_prevented_params =
      ScriptExecutorParams::Create(global_environment(), "return 5;", "[]",
                                   base::TimeDelta::FromMilliseconds(5));
  ASSERT_TRUE(gc_prevented_params.params);
  EXPECT_NE(
      reinterpret_cast<intptr_t>(gc_prevented_params.params->function_object()),
      NULL);
  EXPECT_STREQ(gc_prevented_params.params->json_args().c_str(), "[]");
  EXPECT_EQ(gc_prevented_params.params->async_timeout(), 5);
}

TEST_F(ScriptExecutorTest, CreateInvalidScript) {
  auto gc_prevented_params =
      ScriptExecutorParams::Create(global_environment(), "retarn 5ish;", "[]");
  ASSERT_TRUE(gc_prevented_params.params);
  EXPECT_EQ(
      reinterpret_cast<intptr_t>(gc_prevented_params.params->function_object()),
      NULL);
}

TEST_F(ScriptExecutorTest, ExecuteSync) {
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return \"retval\";", "[]");
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(std::string("\"retval\"")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
}

TEST_F(ScriptExecutorTest, FLAKY_ExecuteAsync) {
  // Create a script that will call the async callback after 50 ms, with
  // an async timeout of 100 ms.
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(),
      "var callback = arguments[0];"
      "window.setTimeout(function() { callback(72); }, 50);",
      "[]", base::TimeDelta::FromMilliseconds(100));
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(std::string("72")));
  EXPECT_CALL(result_handler, OnTimeout()).Times(0);

  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));

  // Let the message loop run for 200ms to allow enough time for the async
  // script to fire the callback.
  base::RunLoop run_loop;
  base::MessageLoop::current()->task_runner()->PostDelayedTask(
      FROM_HERE, run_loop.QuitClosure(),
      base::TimeDelta::FromMilliseconds(200));
  run_loop.Run();
}

TEST_F(ScriptExecutorTest, AsyncTimeout) {
  // Create a script that will call the async callback after 10 seconds, with
  // an async timeout of 100 ms.
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(),
      "var callback = arguments[0];"
      "window.setTimeout(function() { callback(72); }, 10000);",
      "[]", base::TimeDelta::FromMilliseconds(100));
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(_)).Times(0);
  EXPECT_CALL(result_handler, OnTimeout()).Times(1);

  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));

  // Let the message loop run for 200ms to allow enough time for the async
  // timeout to fire.
  base::RunLoop run_loop;
  base::MessageLoop::current()->task_runner()->PostDelayedTask(
      FROM_HERE, run_loop.QuitClosure(),
      base::TimeDelta::FromMilliseconds(200));
  run_loop.Run();
}

TEST_F(ScriptExecutorTest, ScriptThrowsException) {
  auto gc_prevented_params =
      ScriptExecutorParams::Create(global_environment(), "throw Error()", "[]");
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_FALSE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
}

TEST_F(ScriptExecutorTest, ConvertBoolean) {
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return arguments[0];", "[true]");
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(std::string("true")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));

  gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return arguments[0];", "[false]");
  ASSERT_TRUE(gc_prevented_params.params);
  EXPECT_CALL(result_handler, OnResult(std::string("false")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
}

TEST_F(ScriptExecutorTest, ConvertNull) {
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return arguments[0];", "[null]");
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(std::string("null")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
}

TEST_F(ScriptExecutorTest, ConvertNumericType) {
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return arguments[0];", "[6]");
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(std::string("6")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));

  gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return arguments[0];", "[-6.4]");
  ASSERT_TRUE(gc_prevented_params.params);
  EXPECT_CALL(result_handler, OnResult(std::string("-6.4")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
}

TEST_F(ScriptExecutorTest, ConvertString) {
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(), "return arguments[0];", "[\"Mr. T\"]");
  ASSERT_TRUE(gc_prevented_params.params);
  MockScriptExecutorResult result_handler;
  EXPECT_CALL(result_handler, OnResult(std::string("\"Mr. T\"")));
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
}

TEST_F(ScriptExecutorTest, ConvertWebElement) {
  // Create a dom::Element for the MockElementMapping to return.
  scoped_refptr<dom::Element> element =
      window()->document()->CreateElement("p");
  EXPECT_CALL(element_mapping_, IdToElement(protocol::ElementId("id123")))
      .WillRepeatedly(Return(element));
  EXPECT_CALL(element_mapping_, ElementToId(element))
      .WillRepeatedly(Return(protocol::ElementId("id123")));

  // Create a script that will pass a web element argument as a parameter, and
  // return it back. This will invoke the lookup to and from an id.
  auto gc_prevented_params =
      ScriptExecutorParams::Create(global_environment(), "return arguments[0];",
                                   "[ {\"ELEMENT\": \"id123\"} ]");
  ASSERT_TRUE(gc_prevented_params.params);

  // Execute the script and parse the result as JSON, ensuring we got the same
  // web element.
  JSONScriptExecutorResult result_handler;
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
  ASSERT_TRUE(result_handler.json_result());

  std::string element_id;
  base::DictionaryValue* dictionary_value;
  ASSERT_TRUE(result_handler.json_result()->GetAsDictionary(&dictionary_value));
  EXPECT_TRUE(dictionary_value->GetString(protocol::ElementId::kElementKey,
                                          &element_id));
  EXPECT_STREQ(element_id.c_str(), "id123");
}

TEST_F(ScriptExecutorTest, ConvertArray) {
  // Create a script that takes an array of numbers as input, and returns an
  // array of those numbers incremented by one.
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(),
      "return [ (arguments[0][0]+1), (arguments[0][1]+1) ];", "[ [5, 6] ]");
  ASSERT_TRUE(gc_prevented_params.params);

  JSONScriptExecutorResult result_handler;
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
  ASSERT_TRUE(result_handler.json_result());

  base::ListValue* list_value;
  ASSERT_TRUE(result_handler.json_result()->GetAsList(&list_value));
  ASSERT_EQ(list_value->GetSize(), 2);

  int value;
  EXPECT_TRUE(list_value->GetInteger(0, &value));
  EXPECT_EQ(value, 6);
  EXPECT_TRUE(list_value->GetInteger(1, &value));
  EXPECT_EQ(value, 7);
}

TEST_F(ScriptExecutorTest, ConvertObject) {
  // Create a script that takes an Object with two properties as input, and
  // returns an Object with one property that is the sum of the other Object's
  // properties.
  auto gc_prevented_params = ScriptExecutorParams::Create(
      global_environment(),
      "return {\"sum\": arguments[0].a + arguments[0].b};",
      "[ {\"a\":5, \"b\":6} ]");
  ASSERT_TRUE(gc_prevented_params.params);

  JSONScriptExecutorResult result_handler;
  EXPECT_TRUE(
      script_executor_->Execute(gc_prevented_params.params, &result_handler));
  ASSERT_TRUE(result_handler.json_result());

  int value;
  base::DictionaryValue* dictionary_value;
  ASSERT_TRUE(result_handler.json_result()->GetAsDictionary(&dictionary_value));
  EXPECT_TRUE(dictionary_value->GetInteger("sum", &value));
  EXPECT_EQ(value, 11);
}

}  // namespace webdriver
}  // namespace cobalt