// Copyright 2013 The Flutter 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 "flutter/shell/platform/windows/game_pad_cursor_winuwp.h"
#include "game_pad_cursor_winuwp.h"

namespace flutter {

static constexpr int32_t kDefaultPointerDeviceId = 0;

GamepadCursorWinUWP::GamepadCursorWinUWP(
    WindowBindingHandlerDelegate* view,
    DisplayHelperWinUWP* displayhelper,
    winrt::Windows::UI::Core::CoreWindow const& window,
    winrt::Windows::UI::Composition::Compositor const& compositor,
    winrt::Windows::UI::Composition::VisualCollection const& rootcollection) {
  window_ = window;
  root_collection_ = rootcollection;
  binding_handler_delegate_ = view;
  display_helper_ = displayhelper;
  compositor_ = compositor;
  cursor_visual_ = CreateCursorVisual();
  ConfigureGamepad();
}

void GamepadCursorWinUWP::StartGamepadTimer() {
  winrt::Windows::UI::Core::CoreDispatcher dispatcher = window_.Dispatcher();

  dispatcher.RunAsync(
      winrt::Windows::UI::Core::CoreDispatcherPriority::Normal,
      [this, dispatcher]() {
        auto queue =
            winrt::Windows::System::DispatcherQueue::GetForCurrentThread();

        if (cursor_move_timer_ == nullptr) {
          cursor_move_timer_ = queue.CreateTimer();
          cursor_move_timer_.Interval(
              std::chrono::milliseconds(kNormalPollingFrequency));
          cursor_move_timer_.Tick(
              [=](winrt::Windows::System::DispatcherQueueTimer timer,
                  winrt::Windows::Foundation::IInspectable const&) {
                game_pad_->Process();
              });
          cursor_move_timer_.Start();
        }
      });
}

void GamepadCursorWinUWP::StopGamepadTimer() {
  winrt::Windows::UI::Core::CoreDispatcher dispatcher = window_.Dispatcher();

  dispatcher.RunAsync(winrt::Windows::UI::Core::CoreDispatcherPriority::Normal,
                      [this, dispatcher]() {
                        if (cursor_move_timer_ != nullptr) {
                          cursor_move_timer_.Stop();
                          cursor_move_timer_ = nullptr;
                        }
                      });
}

void GamepadCursorWinUWP::ConfigureGamepad() {
  GamepadDualAxisCallback leftStick = [=](double x, double y) {
    OnGamepadLeftStickMoved(x, y);
  };

  GamepadDualAxisCallback rightStick = [=](double x, double y) {
    OnGamepadRightStickMoved(x, y);
  };

  GamepadButtonCallback pressedcallback =
      [=](winrt::Windows::Gaming::Input::GamepadButtons buttons) {
        OnGamepadButtonPressed(buttons);
      };

  GamepadButtonCallback releasedcallback =
      [=](winrt::Windows::Gaming::Input::GamepadButtons buttons) {
        OnGamepadButtonReleased(buttons);
      };
  GamepadAddedRemovedCallback changed = [=]() {
    OnGamepadControllersChanged();
  };

  game_pad_ = std::make_unique<GamepadWinUWP>(leftStick, rightStick, nullptr,
                                              nullptr, pressedcallback,
                                              releasedcallback, changed);
  game_pad_->Initialize();

  SetCursorTimeout();
}

void GamepadCursorWinUWP::SetCursorTimeout() {
  if (cursor_visual_ == nullptr) {
    return;
  }

  auto queue = winrt::Windows::System::DispatcherQueue::GetForCurrentThread();

  // Lazily create timer.
  if (emulated_cursor_hide_timer_ == nullptr) {
    emulated_cursor_hide_timer_ = queue.CreateTimer();
    emulated_cursor_hide_timer_.Interval(std::chrono::seconds(kInactivePeriod));
    emulated_cursor_hide_timer_.Tick(
        [=](winrt::Windows::System::DispatcherQueueTimer timer,
            winrt::Windows::Foundation::IInspectable const&) {
          // Timer fires when user has been inactive.  At this point stop the
          // timer.  It will be restarted next time controller interaction
          // happens triggering SetCursorTimeout
          timer.Stop();

          // If the timer fires, the user hasn't move the cursor for more than
          // the interval hence hide the cursor
          cursor_visual_.IsVisible(false);

          // Reduce mouse move polling frequency while user not interacting with
          // controller
          SetMouseMovePollingFrequency(kReducedPollingFrequency);
        });
  }

  // Ensure the cursor is visible and restart the timer as the user is
  // interacting.
  cursor_visual_.IsVisible(true);
  emulated_cursor_hide_timer_.Start();

  SetMouseMovePollingFrequency(kNormalPollingFrequency);
}

void GamepadCursorWinUWP::SetMouseMovePollingFrequency(int ms) {
  if (cursor_move_timer_ != nullptr) {
    cursor_move_timer_.Interval(std::chrono::milliseconds(ms));
  }
}

winrt::Windows::Foundation::Numerics::float3
GamepadCursorWinUWP::GetScaledInput(
    const winrt::Windows::Foundation::Numerics::float3 input) {
  if (!display_helper_->IsRunningOnLargeScreenDevice()) {
    const float inverse_dpi_scale = display_helper_->GetDpiScale();
    return {cursor_visual_.Offset().x * inverse_dpi_scale,
            cursor_visual_.Offset().y * inverse_dpi_scale, 1.0f};
  } else {
    return std::move(input);
  }
}

void GamepadCursorWinUWP::OnGamepadLeftStickMoved(double x, double y) {
  SetCursorTimeout();

  float new_x =
      cursor_visual_.Offset().x + (kCursorScale * static_cast<float>(x));

  float new_y =
      cursor_visual_.Offset().y + (kCursorScale * -static_cast<float>(y));

  WindowBoundsWinUWP logical_bounds = display_helper_->GetLogicalBounds();

  if (new_x > 0 && new_y > 0 && new_x < logical_bounds.width &&
      new_y < logical_bounds.height) {
    cursor_visual_.Offset({new_x, new_y, 0});

    winrt::Windows::Foundation::Numerics::float3 scaled =
        GetScaledInput(cursor_visual_.Offset());
    // TODO(dnfield): Support for gamepad as a distinct device type?
    // https://github.com/flutter/flutter/issues/80472
    binding_handler_delegate_->OnPointerMove(scaled.x, scaled.y,
                                             kFlutterPointerDeviceKindMouse,
                                             kDefaultPointerDeviceId);
  }
}

void GamepadCursorWinUWP::OnGamepadRightStickMoved(double x, double y) {
  winrt::Windows::Foundation::Numerics::float3 scaled =
      GetScaledInput(cursor_visual_.Offset());
  binding_handler_delegate_->OnScroll(
      scaled.x, scaled.y, x * kControllerScrollMultiplier,
      y * kControllerScrollMultiplier, 1, kFlutterPointerDeviceKindMouse,
      kDefaultPointerDeviceId);
}

void GamepadCursorWinUWP::OnGamepadButtonPressed(
    winrt::Windows::Gaming::Input::GamepadButtons buttons) {
  if ((buttons & winrt::Windows::Gaming::Input::GamepadButtons::A) ==
      winrt::Windows::Gaming::Input::GamepadButtons::A) {
    winrt::Windows::Foundation::Numerics::float3 scaled =
        GetScaledInput(cursor_visual_.Offset());

    // TODO(clarkezone) complete keyboard handling including
    // system key (back), unicode handling, shortcut support,
    // handling defered delivery, remove the need for action value.
    // https://github.com/flutter/flutter/issues/70202

    // TODO(dnfield): Support for gamepad as a distinct device type?
    // https://github.com/flutter/flutter/issues/80472
    binding_handler_delegate_->OnPointerDown(
        scaled.x, scaled.y, kFlutterPointerDeviceKindMouse,
        kDefaultPointerDeviceId,
        FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadLeft) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadLeft) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Left), kScanLeft,
        0x0100, 0, true, true);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadRight) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadRight) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Right), kScanRight,
        0x0100, 0, true, true);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadUp) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadUp) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Up), kScanUp,
        0x0100, 0, true, true);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadDown) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadDown) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Down), kScanDown,
        0x0100, 0, true, true);
  }
}

void GamepadCursorWinUWP::OnGamepadButtonReleased(
    winrt::Windows::Gaming::Input::GamepadButtons buttons) {
  if ((buttons & winrt::Windows::Gaming::Input::GamepadButtons::A) ==
      winrt::Windows::Gaming::Input::GamepadButtons::A) {
    winrt::Windows::Foundation::Numerics::float3 scaled =
        GetScaledInput(cursor_visual_.Offset());

    // TODO(clarkezone) complete keyboard handling including
    // system key (back), unicode handling, shortcut support,
    // handling defered delivery, remove the need for action value.
    // https://github.com/flutter/flutter/issues/70202

    // TODO(dnfield): Support for gamepad as a distinct device type?
    // https://github.com/flutter/flutter/issues/80472
    binding_handler_delegate_->OnPointerUp(
        scaled.x, scaled.y, kFlutterPointerDeviceKindMouse,
        kDefaultPointerDeviceId,
        FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadLeft) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadLeft) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Left), kScanLeft,
        0x0100, 0, true, false);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadRight) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadRight) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Right), kScanRight,
        0x0100, 0, true, false);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadUp) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadUp) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Up), kScanUp,
        0x0100, 0, true, false);
  } else if ((buttons &
              winrt::Windows::Gaming::Input::GamepadButtons::DPadDown) ==
             winrt::Windows::Gaming::Input::GamepadButtons::DPadDown) {
    binding_handler_delegate_->OnKey(
        static_cast<int>(winrt::Windows::System::VirtualKey::Down), kScanDown,
        0x0100, 0, true, false);
  }
}

void GamepadCursorWinUWP::OnGamepadControllersChanged() {
  if (game_pad_->HasController()) {
    if (!cursor_move_timer_) {
      if (cursor_visual_ != nullptr) {
        root_collection_.InsertAtTop(cursor_visual_);
      }
      StartGamepadTimer();
    } else {
      if (cursor_visual_ != nullptr) {
        root_collection_.Remove(cursor_visual_);
      }
      StopGamepadTimer();
    }
  }
}

winrt::Windows::UI::Composition::Visual
GamepadCursorWinUWP::CreateCursorVisual() {
  auto container = compositor_.CreateContainerVisual();
  container.Offset(
      {window_.Bounds().Width / 2, window_.Bounds().Height / 2, 1.0});

  // size of the simulated mouse cursor
  constexpr float size = 20;
  constexpr float container_size = size + 10;
  auto cursor_visual = compositor_.CreateShapeVisual();
  cursor_visual.Size({container_size, container_size});

  // compensate for overscan in cursor visual
  cursor_visual.Offset({display_helper_->GetRenderTargetXOffset(),
                        display_helper_->GetRenderTargetYOffset(), 1.0});

  winrt::Windows::UI::Composition::CompositionEllipseGeometry circle =
      compositor_.CreateEllipseGeometry();
  circle.Radius({size / 2, size / 2});

  auto circleshape = compositor_.CreateSpriteShape(circle);
  circleshape.FillBrush(
      compositor_.CreateColorBrush(winrt::Windows::UI::Colors::Black()));
  circleshape.StrokeBrush(
      compositor_.CreateColorBrush(winrt::Windows::UI::Colors::White()));
  circleshape.StrokeThickness(5.0);
  circleshape.Offset({container_size / 2, container_size / 2});

  cursor_visual.Shapes().Append(circleshape);

  winrt::Windows::UI::Composition::Visual visual =
      cursor_visual.as<winrt::Windows::UI::Composition::Visual>();

  visual.AnchorPoint({0.5, 0.5});
  container.Children().InsertAtTop(visual);

  return container;
}

}  // namespace flutter