// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/modules/animationworklet/animation_worklet_global_scope.h"

#include "base/synchronization/waitable_event.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/mojom/v8_cache_options.mojom-blink.h"
#include "third_party/blink/public/platform/task_type.h"
#include "third_party/blink/public/platform/web_url_request.h"
#include "third_party/blink/renderer/bindings/core/v8/module_record.h"
#include "third_party/blink/renderer/bindings/core/v8/script_source_code.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
#include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/script/classic_script.h"
#include "third_party/blink/renderer/core/testing/page_test_base.h"
#include "third_party/blink/renderer/core/workers/worker_reporting_proxy.h"
#include "third_party/blink/renderer/core/workers/worklet_module_responses_map.h"
#include "third_party/blink/renderer/modules/animationworklet/animation_worklet.h"
#include "third_party/blink/renderer/modules/animationworklet/animation_worklet_proxy_client.h"
#include "third_party/blink/renderer/modules/animationworklet/animator.h"
#include "third_party/blink/renderer/modules/animationworklet/animator_definition.h"
#include "third_party/blink/renderer/modules/worklet/worklet_thread_test_common.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
#include "third_party/blink/renderer/platform/wtf/text/text_position.h"

#include <memory>

namespace blink {
namespace {

class MockAnimationWorkletProxyClient : public AnimationWorkletProxyClient {
 public:
  MockAnimationWorkletProxyClient()
      : AnimationWorkletProxyClient(0, nullptr, nullptr, nullptr, nullptr),
        did_add_global_scope_(false) {}
  void AddGlobalScope(WorkletGlobalScope*) override {
    did_add_global_scope_ = true;
  }
  void SynchronizeAnimatorName(const String&) override {}
  bool did_add_global_scope() { return did_add_global_scope_; }

 private:
  bool did_add_global_scope_;
};

std::unique_ptr<AnimationWorkletOutput> ProxyClientMutate(
    AnimationWorkletInput& state,
    AnimationWorkletGlobalScope* global_scope) {
  std::unique_ptr<AnimationWorkletOutput> output =
      std::make_unique<AnimationWorkletOutput>();
  global_scope->UpdateAnimatorsList(state);
  global_scope->UpdateAnimators(state, output.get(),
                                [](Animator*) { return true; });
  return output;
}

std::unique_ptr<WorkletAnimationEffectTimings> CreateEffectTimings() {
  auto timings = base::MakeRefCounted<base::RefCountedData<Vector<Timing>>>();
  timings->data.push_back(Timing());
  return std::make_unique<WorkletAnimationEffectTimings>(std::move(timings));
}

}  // namespace

class AnimationWorkletGlobalScopeTest : public PageTestBase {
 public:
  AnimationWorkletGlobalScopeTest() = default;

  void SetUp() override {
    PageTestBase::SetUp(IntSize());
    NavigateTo(KURL("https://example.com/"));
    reporting_proxy_ = std::make_unique<WorkerReportingProxy>();
  }

  using TestCalback = void (
      AnimationWorkletGlobalScopeTest::*)(WorkerThread*, base::WaitableEvent*);
  // Create a new animation worklet and run the callback task on it. Terminate
  // the worklet once the task completion is signaled.
  void RunTestOnWorkletThread(TestCalback callback) {
    std::unique_ptr<WorkerThread> worklet =
        CreateThreadAndProvideAnimationWorkletProxyClient(
            &GetDocument(), reporting_proxy_.get());
    base::WaitableEvent waitable_event;
    PostCrossThreadTask(
        *worklet->GetTaskRunner(TaskType::kInternalTest), FROM_HERE,
        CrossThreadBindOnce(callback, CrossThreadUnretained(this),
                            CrossThreadUnretained(worklet.get()),
                            CrossThreadUnretained(&waitable_event)));
    waitable_event.Wait();

    worklet->Terminate();
    worklet->WaitForShutdownForTesting();
  }

  void RunScriptOnWorklet(String source_code,
                          WorkerThread* thread,
                          base::WaitableEvent* waitable_event) {
    ASSERT_TRUE(thread->IsCurrentThread());
    auto* global_scope = To<AnimationWorkletGlobalScope>(thread->GlobalScope());
    ASSERT_TRUE(
        ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(source_code))
            ->RunScriptOnWorkerOrWorklet(*global_scope));

    waitable_event->Signal();
  }

  void RunBasicParsingTestOnWorklet(WorkerThread* thread,
                                    base::WaitableEvent* waitable_event) {
    ASSERT_TRUE(thread->IsCurrentThread());
    auto* global_scope = To<AnimationWorkletGlobalScope>(thread->GlobalScope());

    {
      // registerAnimator() with a valid class definition should define an
      // animator.
      String source_code =
          R"JS(
            registerAnimator('test', class {
              constructor () {}
              animate () {}
            });
          )JS";
      ASSERT_TRUE(
          ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(source_code))
              ->RunScriptOnWorkerOrWorklet(*global_scope));

      AnimatorDefinition* definition =
          global_scope->FindDefinitionForTest("test");
      ASSERT_TRUE(definition);
    }

    {
      // registerAnimator() with a null class definition should fail to define
      // an animator.
      String source_code = "registerAnimator('null', null);";
      ASSERT_FALSE(
          ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(source_code))
              ->RunScriptOnWorkerOrWorklet(*global_scope));
      EXPECT_FALSE(global_scope->FindDefinitionForTest("null"));
    }

    EXPECT_FALSE(global_scope->FindDefinitionForTest("non-existent"));

    waitable_event->Signal();
  }

  static bool RunScriptAndGetBoolean(AnimationWorkletGlobalScope* global_scope,
                                     const String& script) {
    ScriptState* script_state =
        global_scope->ScriptController()->GetScriptState();
    DCHECK(script_state);
    v8::Isolate* isolate = script_state->GetIsolate();
    DCHECK(isolate);
    v8::HandleScope scope(isolate);

    ClassicScript* classic_script =
        ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(script));

    ScriptEvaluationResult result =
        classic_script->RunScriptOnScriptStateAndReturnValue(script_state);
    DCHECK_EQ(result.GetResultType(),
              ScriptEvaluationResult::ResultType::kSuccess);
    return ToBoolean(isolate, result.GetSuccessValue(), ASSERT_NO_EXCEPTION);
  }

  void RunConstructAndAnimateTestOnWorklet(
      WorkerThread* thread,
      base::WaitableEvent* waitable_event) {
    ASSERT_TRUE(thread->IsCurrentThread());
    auto* global_scope = To<AnimationWorkletGlobalScope>(thread->GlobalScope());

    String source_code =
        R"JS(
            // Worklet doesn't have a reference to the global object. Instead,
            // retrieve it in a tricky way.
            var global_object = Function('return this')();
            global_object.constructed = false;
            global_object.animated = false;

            registerAnimator('test', class {
              constructor () {
                constructed = true;
              }
              animate () {
                animated = true;
              }
            });
        )JS";
    ASSERT_TRUE(
        ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(source_code))
            ->RunScriptOnWorkerOrWorklet(*global_scope));

    EXPECT_FALSE(RunScriptAndGetBoolean(
        global_scope, "Function('return this')().constructed"))
        << "constructor is not invoked";

    EXPECT_FALSE(RunScriptAndGetBoolean(global_scope,
                                        "Function('return this')().animated"))
        << "animate function is invoked early";

    // Passing a new input state with a new animation id should cause the
    // worklet to create and animate an animator.
    cc::WorkletAnimationId animation_id = {1, 1};
    AnimationWorkletInput state;
    std::unique_ptr<WorkletAnimationEffectTimings> effect_timings =
        CreateEffectTimings();
    state.added_and_updated_animations.emplace_back(
        animation_id, "test", 5000, nullptr, std::move(effect_timings));

    std::unique_ptr<AnimationWorkletOutput> output =
        ProxyClientMutate(state, global_scope);
    EXPECT_EQ(output->animations.size(), 1ul);

    EXPECT_TRUE(RunScriptAndGetBoolean(global_scope,
                                       "Function('return this')().constructed"))
        << "constructor is not invoked";

    EXPECT_TRUE(RunScriptAndGetBoolean(global_scope,
                                       "Function('return this')().animated"))
        << "animate function is not invoked";

    waitable_event->Signal();
  }

  void RunStateExistenceTestOnWorklet(WorkerThread* thread,
                                      base::WaitableEvent* waitable_event) {
    ASSERT_TRUE(thread->IsCurrentThread());
    auto* global_scope = To<AnimationWorkletGlobalScope>(thread->GlobalScope());
    String source_code =
        R"JS(
            class Stateful {
              animate () {}
              state () {}
            }

            class Stateless {
              animate () {}
            }

            class Foo {
              animate () {}
            }
            Foo.prototype.state = function() {};

            registerAnimator('stateful_animator', Stateful);
            registerAnimator('stateless_animator', Stateless);
            registerAnimator('foo', Foo);
        )JS";
    ASSERT_TRUE(
        ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(source_code))
            ->RunScriptOnWorkerOrWorklet(*global_scope));

    AnimatorDefinition* first_definition =
        global_scope->FindDefinitionForTest("stateful_animator");
    EXPECT_TRUE(first_definition->IsStateful());
    AnimatorDefinition* second_definition =
        global_scope->FindDefinitionForTest("stateless_animator");
    EXPECT_FALSE(second_definition->IsStateful());
    AnimatorDefinition* third_definition =
        global_scope->FindDefinitionForTest("foo");
    EXPECT_TRUE(third_definition->IsStateful());

    waitable_event->Signal();
  }

  void RunAnimateOutputTestOnWorklet(WorkerThread* thread,
                                     base::WaitableEvent* waitable_event) {
    AnimationWorkletGlobalScope* global_scope =
        static_cast<AnimationWorkletGlobalScope*>(thread->GlobalScope());
    ASSERT_TRUE(global_scope);
    ASSERT_TRUE(global_scope->IsAnimationWorkletGlobalScope());
    ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(
                                               R"JS(
            registerAnimator('test', class {
              animate (currentTime, effect) {
                effect.localTime = 123;
              }
            });
          )JS"))
        ->RunScriptOnWorkerOrWorklet(*global_scope);

    // Passing a new input state with a new animation id should cause the
    // worklet to create and animate an animator.
    cc::WorkletAnimationId animation_id = {1, 1};
    AnimationWorkletInput state;
    std::unique_ptr<WorkletAnimationEffectTimings> effect_timings =
        CreateEffectTimings();
    state.added_and_updated_animations.emplace_back(
        animation_id, "test", 5000, nullptr, std::move(effect_timings));

    std::unique_ptr<AnimationWorkletOutput> output =
        ProxyClientMutate(state, global_scope);

    EXPECT_EQ(output->animations.size(), 1ul);
    EXPECT_EQ(output->animations[0].local_times[0],
              base::TimeDelta::FromMillisecondsD(123));

    waitable_event->Signal();
  }

  // This test verifies that an animator instance is not created if
  // MutatorInputState does not have an animation in
  // added_and_updated_animations.
  void RunAnimatorInstanceCreationTestOnWorklet(
      WorkerThread* thread,
      base::WaitableEvent* waitable_event) {
    AnimationWorkletGlobalScope* global_scope =
        static_cast<AnimationWorkletGlobalScope*>(thread->GlobalScope());
    ASSERT_TRUE(global_scope);
    ASSERT_TRUE(global_scope->IsAnimationWorkletGlobalScope());
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 0u);
    ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(
                                               R"JS(
            registerAnimator('test', class {
              animate (currentTime, effect) {
                effect.localTime = 123;
              }
            });
          )JS"))
        ->RunScriptOnWorkerOrWorklet(*global_scope);

    cc::WorkletAnimationId animation_id = {1, 1};
    AnimationWorkletInput state;
    state.updated_animations.push_back({animation_id, 5000});
    EXPECT_EQ(state.added_and_updated_animations.size(), 0u);
    EXPECT_EQ(state.updated_animations.size(), 1u);

    std::unique_ptr<AnimationWorkletOutput> output =
        ProxyClientMutate(state, global_scope);
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 0u);

    state.removed_animations.push_back(animation_id);
    EXPECT_EQ(state.added_and_updated_animations.size(), 0u);
    EXPECT_EQ(state.removed_animations.size(), 1u);

    output = ProxyClientMutate(state, global_scope);
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 0u);

    std::unique_ptr<WorkletAnimationEffectTimings> effect_timings =
        CreateEffectTimings();
    state.added_and_updated_animations.push_back(
        {animation_id, "test", 5000, nullptr, std::move(effect_timings)});
    EXPECT_EQ(state.added_and_updated_animations.size(), 1u);

    output = ProxyClientMutate(state, global_scope);
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 1u);
    waitable_event->Signal();
  }

  // This test verifies that an animator instance is created and removed
  // properly.
  void RunAnimatorInstanceUpdateTestOnWorklet(
      WorkerThread* thread,
      base::WaitableEvent* waitable_event) {
    AnimationWorkletGlobalScope* global_scope =
        static_cast<AnimationWorkletGlobalScope*>(thread->GlobalScope());
    ASSERT_TRUE(global_scope);
    ASSERT_TRUE(global_scope->IsAnimationWorkletGlobalScope());
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 0u);
    ClassicScript::CreateUnspecifiedScript(ScriptSourceCode(
                                               R"JS(
            registerAnimator('test', class {
              animate (currentTime, effect) {
                effect.localTime = 123;
              }
            });
          )JS"))
        ->RunScriptOnWorkerOrWorklet(*global_scope);

    cc::WorkletAnimationId animation_id = {1, 1};
    AnimationWorkletInput state;
    std::unique_ptr<WorkletAnimationEffectTimings> effect_timings =
        CreateEffectTimings();
    state.added_and_updated_animations.push_back(
        {animation_id, "test", 5000, nullptr, std::move(effect_timings)});
    EXPECT_EQ(state.added_and_updated_animations.size(), 1u);

    std::unique_ptr<AnimationWorkletOutput> output =
        ProxyClientMutate(state, global_scope);
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 1u);

    state.added_and_updated_animations.clear();
    state.updated_animations.push_back({animation_id, 6000});
    EXPECT_EQ(state.added_and_updated_animations.size(), 0u);
    EXPECT_EQ(state.updated_animations.size(), 1u);

    output = ProxyClientMutate(state, global_scope);
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 1u);

    state.updated_animations.clear();
    state.removed_animations.push_back(animation_id);
    EXPECT_EQ(state.updated_animations.size(), 0u);
    EXPECT_EQ(state.removed_animations.size(), 1u);

    output = ProxyClientMutate(state, global_scope);
    EXPECT_EQ(global_scope->GetAnimatorsSizeForTest(), 0u);

    waitable_event->Signal();
  }

  std::unique_ptr<WorkerReportingProxy> reporting_proxy_;
};

TEST_F(AnimationWorkletGlobalScopeTest, BasicParsing) {
  RunTestOnWorkletThread(
      &AnimationWorkletGlobalScopeTest::RunBasicParsingTestOnWorklet);
}

TEST_F(AnimationWorkletGlobalScopeTest, ConstructAndAnimate) {
  RunTestOnWorkletThread(
      &AnimationWorkletGlobalScopeTest::RunConstructAndAnimateTestOnWorklet);
}

TEST_F(AnimationWorkletGlobalScopeTest, StateExistence) {
  RunTestOnWorkletThread(
      &AnimationWorkletGlobalScopeTest::RunStateExistenceTestOnWorklet);
}

TEST_F(AnimationWorkletGlobalScopeTest, AnimationOutput) {
  RunTestOnWorkletThread(
      &AnimationWorkletGlobalScopeTest::RunAnimateOutputTestOnWorklet);
}

TEST_F(AnimationWorkletGlobalScopeTest, AnimatorInstanceCreation) {
  RunTestOnWorkletThread(&AnimationWorkletGlobalScopeTest::
                             RunAnimatorInstanceCreationTestOnWorklet);
}

TEST_F(AnimationWorkletGlobalScopeTest, AnimatorInstanceUpdate) {
  RunTestOnWorkletThread(
      &AnimationWorkletGlobalScopeTest::RunAnimatorInstanceUpdateTestOnWorklet);
}

TEST_F(AnimationWorkletGlobalScopeTest,
       ShouldRegisterItselfAfterFirstAnimatorRegistration) {
  MockAnimationWorkletProxyClient* proxy_client =
      MakeGarbageCollected<MockAnimationWorkletProxyClient>();
  std::unique_ptr<WorkerThread> worklet =
      CreateThreadAndProvideAnimationWorkletProxyClient(
          &GetDocument(), reporting_proxy_.get(), proxy_client);
  // Animation worklet global scope (AWGS) should not register itself upon
  // creation.
  EXPECT_FALSE(proxy_client->did_add_global_scope());

  base::WaitableEvent waitable_event;
  String source_code =
      R"JS(
        registerAnimator('test', class {
          constructor () {}
          animate () {}
        });
      )JS";
  PostCrossThreadTask(
      *worklet->GetTaskRunner(TaskType::kInternalTest), FROM_HERE,
      CrossThreadBindOnce(&AnimationWorkletGlobalScopeTest::RunScriptOnWorklet,
                          CrossThreadUnretained(this), std::move(source_code),
                          CrossThreadUnretained(worklet.get()),
                          CrossThreadUnretained(&waitable_event)));
  waitable_event.Wait();

  // AWGS should register itself first time an animator is registered with it.
  EXPECT_TRUE(proxy_client->did_add_global_scope());

  worklet->Terminate();
  worklet->WaitForShutdownForTesting();
}

}  // namespace blink