// Copyright 2020 The Fuchsia 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 <fuchsia/test/ui/cpp/fidl.h>
#include <fuchsia/ui/app/cpp/fidl.h>
#include <fuchsia/ui/gfx/cpp/fidl.h>
#include <fuchsia/ui/input/cpp/fidl.h>
#include <fuchsia/ui/scenic/cpp/fidl.h>
#include <fuchsia/ui/views/cpp/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/fidl/cpp/binding.h>
#include <lib/fidl/cpp/interface_handle.h>
#include <lib/fidl/cpp/interface_request.h>
#include <lib/fostr/fidl/fuchsia/ui/gfx/formatting.h>
#include <lib/fostr/fidl/fuchsia/ui/input/formatting.h>
#include <lib/sys/cpp/component_context.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/syslog/global.h>
#include <lib/ui/scenic/cpp/resources.h>
#include <lib/zx/eventpair.h>
#include <zircon/status.h>

#include <array>
#include <memory>

namespace cpp_gfx_client {

// Implementation of a very simple Scenic client.
class CppGfxClient : public fuchsia::ui::app::ViewProvider {
 public:
  CppGfxClient(async::Loop* loop) : loop_(loop), view_provider_binding_(this) {
    FX_CHECK(loop_);

    context_ = sys::ComponentContext::CreateAndServeOutgoingDirectory();
    context_->outgoing()->AddPublicService<fuchsia::ui::app::ViewProvider>(
        [this](fidl::InterfaceRequest<fuchsia::ui::app::ViewProvider> request) {
          view_provider_binding_.Bind(std::move(request));
        });

    response_listener_ = context_->svc()->Connect<fuchsia::test::ui::ResponseListener>();
    response_listener_.set_error_handler([](zx_status_t status) {
      FX_LOGS(WARNING) << "JFYI. Test response listener disconnected, status: " <<
      zx_status_get_string(status);
      // Don't quit, because we should be able to run this client outside of a test.
    });

    scenic_ = context_->svc()->Connect<fuchsia::ui::scenic::Scenic>();
    scenic_.set_error_handler([this](zx_status_t status) {
      FX_LOGS(ERROR) << "Quitting. Scenic disconnected, status: " << zx_status_get_string(status);
      loop_->Quit();
    });

    session_ = std::make_unique<scenic::Session>(scenic_.get());
    session_->set_error_handler([this](zx_status_t status) {
      FX_LOGS(ERROR) << "Quitting. Scenic session disconnected, status: " <<
      zx_status_get_string(status); loop_->Quit();
    });
    session_->set_event_handler(fit::bind_member(this, &CppGfxClient::OnEvents));
    session_->set_on_frame_presented_handler([](auto frame_presented_info) {});

    root_node_ = std::make_unique<scenic::EntityNode>(session_.get());
    root_node_->SetEventMask(fuchsia::ui::gfx::kMetricsEventMask);

    session_->Present2(zx_clock_get_monotonic(), 0, [](auto future_presentation_times) {});
  }

 private:
  static constexpr std::array<std::array<uint8_t, 4>, 6> kColorsRgba = {
      {{255, 0, 0, 255},      // red
       {255, 128, 0, 255},    // orange
       {255, 255, 0, 255},    // yellow
       {0, 255, 0, 255},      // green
       {0, 0, 255, 255},      // blue
       {128, 0, 255, 255}}};  // purple

  // |fuchsia::ui::app::ViewProvider|
  void CreateView(zx::eventpair token,
                  fidl::InterfaceRequest<fuchsia::sys::ServiceProvider> /*unused*/,
                  fidl::InterfaceHandle<fuchsia::sys::ServiceProvider> /*unused*/) override {
    FX_LOGS(INFO) << "CreateView called.";

    view_ = std::make_unique<scenic::View>(session_.get(), std::move(token), "cpp-gfx-client view");
    view_->AddChild(*root_node_);

    session_->Present2(zx_clock_get_monotonic(), 0, [](auto future_presentation_times) {});
  }

  // |fuchsia::ui::app::ViewProvider|
  void CreateViewWithViewRef(zx::eventpair token,
                             fuchsia::ui::views::ViewRefControl view_ref_control,
                             fuchsia::ui::views::ViewRef view_ref) override {
    FX_LOGS(INFO) << "CreateViewWithViewRef called.";

    view_ = std::make_unique<scenic::View>(
        session_.get(), fuchsia::ui::views::ViewToken{.value = std::move(token)},
        std::move(view_ref_control), std::move(view_ref), "cpp-gfx-client view");
    view_->AddChild(*root_node_);

    session_->Present2(zx_clock_get_monotonic(), 0, [](auto future_presentation_times) {});
  }

  // Scenic Session event handler, passed to |fuchsia::ui::scenic::SessionListener|.
  void OnEvents(std::vector<fuchsia::ui::scenic::Event> events) {
    for (const auto& event : events) {
      if (event.is_gfx()) {
        switch (event.gfx().Which()) {
          case fuchsia::ui::gfx::Event::Tag::kMetrics: {
            FX_LOGS(INFO) << "Metrics received.";
            metrics_ = event.gfx().metrics().metrics;
            break;
          }
          case fuchsia::ui::gfx::Event::Tag::kViewPropertiesChanged: {
            FX_LOGS(INFO) << "View properties received.";
            view_properties_ = event.gfx().view_properties_changed().properties;
            break;
          }
          default:
            break;  // nop
        }
      } else if (event.is_input()) {
        switch (event.input().Which()) {
          case fuchsia::ui::input::InputEvent::Tag::kPointer: {
            if (event.input().pointer().phase == fuchsia::ui::input::PointerEventPhase::DOWN &&
                material_) {
              {
                // Cycle to next color.
                color_index_ = (color_index_ + 1) % kColorsRgba.size();
                std::array<uint8_t, 4> color = kColorsRgba[color_index_];
                material_->SetColor(color[0], color[1], color[2], color[3]);
                session_->Present2(zx_clock_get_monotonic(), 0,
                                   [](auto future_presentation_times) {});
              }

              if (response_listener_) {
                fuchsia::test::ui::PointerData data;
                // The raw pointer event's coordinates are in pips (logical pixels). The test
                // expects coordinates in physical pixels. The former is transformed into the latter
                // with the scale factor provided in the metrics event.
                data.set_local_x(event.input().pointer().x * metrics_.scale_x);
                data.set_local_y(event.input().pointer().y * metrics_.scale_y);
                data.set_time_received(zx_clock_get_monotonic());
                response_listener_->Respond(std::move(data));
              }
            }
            break;
          }
          default:
            break;  // nop
        }
      }
    }

    if (!scene_created_ && ViewSize().x > 0 && ViewSize().y > 0) {
      CreateScene();
      scene_created_ = true;
    }
  }

  // Calculates view size based on view properties and metrics event.
  fuchsia::ui::gfx::vec2 ViewSize() const {
    const fuchsia::ui::gfx::ViewProperties& p = view_properties_;
    float size_x = ((p.bounding_box.max.x - p.inset_from_max.x) -
                    (p.bounding_box.min.x + p.inset_from_min.x)) *
                   metrics_.scale_x;
    float size_y = ((p.bounding_box.max.y - p.inset_from_max.y) -
                    (p.bounding_box.min.y + p.inset_from_min.y)) *
                   metrics_.scale_y;
    return fuchsia::ui::gfx::vec2{.x = size_x, .y = size_y};
  }

  // Encapsulates scene setup.
  void CreateScene() {
    FX_CHECK(session_) << "precondition";
    FX_CHECK(root_node_) << "precondition";

    scenic::Session* session = session_.get();

    scenic::ShapeNode shape(session);
    scenic::Rectangle rec(session, ViewSize().x, ViewSize().y);
    shape.SetShape(rec);
    shape.SetTranslation(ViewSize().x / 2, ViewSize().y / 2, 0.f);
    material_ = std::make_unique<scenic::Material>(session);
    std::array<uint8_t, 4> color = kColorsRgba[color_index_];
    material_->SetColor(color[0], color[1], color[2], color[3]);
    shape.SetMaterial(*material_);
    root_node_->AddChild(shape);

    session_->Present2(zx_clock_get_monotonic(), 0, [](auto future_presentation_times) {});
  }

  // The main thread's message loop.
  async::Loop* loop_ = nullptr;

  // This component's global context.
  std::unique_ptr<sys::ComponentContext> context_;

  // Protocols used by this component.
  fuchsia::ui::scenic::ScenicPtr scenic_;
  fuchsia::test::ui::ResponseListenerPtr response_listener_;

  // Protocols vended by this component.
  fidl::Binding<fuchsia::ui::app::ViewProvider> view_provider_binding_;

  // Scene state.
  std::unique_ptr<scenic::Session> session_;
  std::unique_ptr<scenic::View> view_;
  std::unique_ptr<scenic::EntityNode> root_node_;
  std::unique_ptr<scenic::Material> material_;
  fuchsia::ui::gfx::ViewProperties view_properties_;
  fuchsia::ui::gfx::Metrics metrics_;
  bool scene_created_ = false;
  uint32_t color_index_ = 0;
};
}  // namespace cpp_gfx_client

// Component entry point.
int main(int argc, char** argv) {
  FX_LOGS(INFO) << "Starting cpp-gfx-client.";

  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);
  cpp_gfx_client::CppGfxClient client(&loop);

  return loop.Run();
}