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

#include "ash/display/unified_mouse_warp_controller.h"

#include <sstream>

#include "ash/display/display_util.h"
#include "ash/display/mirror_window_controller.h"
#include "ash/display/mouse_cursor_event_filter.h"
#include "ash/display/window_tree_host_manager.h"
#include "ash/host/ash_window_tree_host.h"
#include "ash/shell.h"
#include "ash/test/ash_test_base.h"
#include "ui/aura/env.h"
#include "ui/aura/window_tree_host.h"
#include "ui/display/display.h"
#include "ui/display/display_finder.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/screen.h"
#include "ui/events/test/event_generator.h"
#include "ui/wm/core/coordinate_conversion.h"

namespace ash {

namespace {

struct WarpGroup {
  // Native point at a warp edge before warping.
  gfx::Point native_point_at_edge;

  // Expected DIP point after warping.
  gfx::Point expected_point_after_warp;

  // Expected display ID after warping.
  int64_t expected_target_display_id;
};

}  // namespace

class UnifiedMouseWarpControllerTest : public AshTestBase {
 public:
  UnifiedMouseWarpControllerTest() = default;

  UnifiedMouseWarpControllerTest(const UnifiedMouseWarpControllerTest&) =
      delete;
  UnifiedMouseWarpControllerTest& operator=(
      const UnifiedMouseWarpControllerTest&) = delete;

  ~UnifiedMouseWarpControllerTest() override = default;

  void SetUp() override {
    AshTestBase::SetUp();
    display_manager()->SetUnifiedDesktopEnabled(true);
  }

 protected:
  bool MoveMouseToNativePoint(const gfx::Point& point_in_native,
                              int64_t* out_original_mirroring_display_id) {
    for (auto display : display_manager()->software_mirroring_display_list()) {
      display::ManagedDisplayInfo info =
          display_manager()->GetDisplayInfo(display.id());
      if (info.bounds_in_native().Contains(point_in_native)) {
        *out_original_mirroring_display_id = info.id();
        gfx::Point point_in_mirroring_host = point_in_native;
        const gfx::Point& origin = info.bounds_in_native().origin();
        // Convert to mirroring host.
        point_in_mirroring_host.Offset(-origin.x(), -origin.y());

        // Move the mouse inside the host.
        AshWindowTreeHost* ash_host =
            Shell::Get()
                ->window_tree_host_manager()
                ->mirror_window_controller()
                ->GetAshWindowTreeHostForDisplayId(info.id());
        ui::test::EventGenerator gen(ash_host->AsWindowTreeHost()->window());
        gen.MoveMouseToWithNative(point_in_mirroring_host,
                                  point_in_mirroring_host);
        return true;
      }
    }
    return false;
  }

  bool TestIfMouseWarpsAt(const gfx::Point& point_in_native) {
    static_cast<UnifiedMouseWarpController*>(
        Shell::Get()->mouse_cursor_filter()->mouse_warp_controller_for_test())
        ->update_location_for_test();
    int64_t orig_mirroring_display_id;
    if (!MoveMouseToNativePoint(point_in_native, &orig_mirroring_display_id))
      return false;

    aura::Window* root = Shell::GetPrimaryRootWindow();
    gfx::Point new_location_in_unified_host =
        aura::Env::GetInstance()->last_mouse_location();
    // Convert screen to the host.
    root->GetHost()->ConvertDIPToPixels(&new_location_in_unified_host);

    auto iter = display::FindDisplayContainingPoint(
        display_manager()->software_mirroring_display_list(),
        new_location_in_unified_host);
    if (iter == display_manager()->software_mirroring_display_list().end())
      return false;
    return orig_mirroring_display_id != iter->id();
  }

  MouseCursorEventFilter* event_filter() {
    return Shell::Get()->mouse_cursor_filter();
  }

  UnifiedMouseWarpController* mouse_warp_controller() {
    return static_cast<UnifiedMouseWarpController*>(
        event_filter()->mouse_warp_controller_for_test());
  }

  // |expected_edges| should have a row for each display which contains the
  // expected native bounds of the shared edges with that display in the order
  // "top", "left", "right", "bottom".
  // If |matrix| is empty, default unified layout will be used.
  void BoundaryTestBody(
      const std::string& displays_specs,
      const display::UnifiedDesktopLayoutMatrix& matrix,
      const std::vector<std::vector<std::string>>& expected_edges) {
    UpdateDisplay(displays_specs);
    display_manager()->SetUnifiedDesktopMatrix(matrix);

    // Let the UnifiedMouseWarpController compute the bounds by
    // generating a mouse move event.
    GetEventGenerator()->MoveMouseTo(gfx::Point(0, 0));
    const display::Displays& mirroring_displays =
        display_manager()->software_mirroring_display_list();

    ASSERT_EQ(expected_edges.size(), mirroring_displays.size());
    int index = 0;
    for (const auto& display : mirroring_displays) {
      const int64_t id = display.id();
      std::stringstream scoped_trace_message;
      scoped_trace_message << "Edges of display with ID: " << id
                           << " at index: " << index;
      SCOPED_TRACE(scoped_trace_message.str());
      const auto& display_expected_edges = expected_edges[index++];
      const auto& display_actual_edges =
          mouse_warp_controller()->displays_edges_map_.at(id);
      ASSERT_EQ(display_expected_edges.size(), display_actual_edges.size());
      for (size_t i = 0; i < display_expected_edges.size(); ++i) {
        EXPECT_EQ(display_expected_edges[i],
                  display_actual_edges[i]
                      .edge_native_bounds_in_source_display.ToString());
      }
    }
  }

  void WarpTestBody(const std::vector<WarpGroup>& warp_groups) {
    for (const auto& group : warp_groups) {
      EXPECT_TRUE(TestIfMouseWarpsAt(group.native_point_at_edge));

      gfx::Point new_location = aura::Env::GetInstance()->last_mouse_location();
      EXPECT_EQ(group.expected_point_after_warp, new_location);

      // Convert screen to the host.
      aura::Window* root = Shell::GetPrimaryRootWindow();
      root->GetHost()->ConvertDIPToPixels(&new_location);

      auto iter = display::FindDisplayContainingPoint(
          display_manager()->software_mirroring_display_list(), new_location);
      EXPECT_FALSE(iter ==
                   display_manager()->software_mirroring_display_list().end());
      EXPECT_EQ(group.expected_target_display_id, iter->id());
    }
  }

  void NoWarpTestBody() {
    // Touch the left edge of the first display.
    EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(0, 10)));
    // Touch the top edge of the first display.
    EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(10, 0)));
    // Touch the bottom edge of the first display.
    EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(10, 499)));

    // Touch the right edge of the second display.
    EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(1099, 10)));
    // Touch the top edge of the second display.
    EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(610, 0)));
    // Touch the bottom edge of the second display.
    EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(610, 499)));
  }
};

// Verifies if MouseCursorEventFilter's bounds calculation works correctly.
TEST_F(UnifiedMouseWarpControllerTest, BoundaryTest) {
  {
    SCOPED_TRACE("1x1");
    BoundaryTestBody("500x400,0+450-700x400",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x400"}});
    BoundaryTestBody("500x400,0+450-700x600",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x600"}});
  }
  {
    SCOPED_TRACE("2x1");
    BoundaryTestBody("500x400*2,0+450-700x400",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x400"}});
    BoundaryTestBody("500x400*2,0+450-700x600",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x600"}});
  }
  {
    SCOPED_TRACE("1x2");
    BoundaryTestBody("500x400,0+450-700x400*2",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x400"}});
    BoundaryTestBody("500x400,0+450-700x600*2",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x600"}});
  }
  {
    SCOPED_TRACE("2x2");
    BoundaryTestBody("500x400*2,0+450-700x400*2",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x400"}});
    BoundaryTestBody("500x400*2,0+450-700x600*2",
                     {},  // Empty matrix (use horizontal layout).
                     {{"499,0 1x400"}, {"0,450 1x600"}});
  }
}

TEST_F(UnifiedMouseWarpControllerTest, BoundaryAndWarpSimpleTest) {
  const std::vector<std::vector<std::string>> expected_edges = {
      // Display 0 edges.
      {
          "1919,0 1x1080",  // Right with display 1.
      },
      // Display 1 edges.
      {
          "1930,0 1x1200",  // Left with display 0.
      },
  };

  BoundaryTestBody("0+0-1920x1080,1930+0-1920x1200",
                   {} /* empty matrix = default */, expected_edges);

  display::DisplayIdList list = display_manager()->GetConnectedDisplayIdList();
  ASSERT_EQ(2u, list.size());

  // Assert mouse warps in all bounds to the correct display.
  const std::vector<WarpGroup> warp_groups = {
      {{1919, 500}, {1920, 499}, list[1]},  // Display 0 --> 1.
      {{1930, 600}, {1918, 540}, list[0]},  // Display 1 --> 0.
  };
  WarpTestBody(warp_groups);
}

TEST_F(UnifiedMouseWarpControllerTest, BoundaryTestGrid) {
  // Update displays here first so we get the correct display IDs list. The
  // below are the native bounds.
  const std::string display_specs =
      "0+0-500x300,510+0-400x500,920+0-300x600,"
      "0+600-200x300,210+600-700x200,920+600-350x480,"
      "0+1080-300x500,310+1080-600x599,920+1080-400x450";
  UpdateDisplay(display_specs);
  display_manager()->SetUnifiedDesktopEnabled(true);
  display::DisplayIdList list = display_manager()->GetConnectedDisplayIdList();
  ASSERT_EQ(9u, list.size());

  // Test a very general case of a 3 x 3 matrix.
  // 0:[500 x 300] 1:[400 x 500] 2:[300 x 600]
  // 3:[200 x 300] 4:[700 x 200] 5:[350 x 480]
  // 6:[300 x 500] 7:[600 x 599] 8:[400 x 450]
  display::UnifiedDesktopLayoutMatrix matrix;
  matrix.resize(3u);
  matrix[0].emplace_back(list[0]);
  matrix[0].emplace_back(list[1]);
  matrix[0].emplace_back(list[2]);
  matrix[1].emplace_back(list[3]);
  matrix[1].emplace_back(list[4]);
  matrix[1].emplace_back(list[5]);
  matrix[2].emplace_back(list[6]);
  matrix[2].emplace_back(list[7]);
  matrix[2].emplace_back(list[8]);

  const std::vector<std::vector<std::string>> expected_edges = {
      // Display 0 edges.
      {
          "499,0 1x300",    // Right with display 1.
          "0,299 121x1",    // Bottom with display 3.
          "121,299 379x1",  // Bottom with display 4.
      },
      // Display 1 edges.
      {
          "510,0 1x500",    // Left with display 0.
          "909,0 1x500",    // Right with display 2.
          "510,499 400x1",  // Bottom with display 4.
      },
      // Display 2 edges.
      {
          "920,0 1x600",    // Left with display 1.
          "920,599 34x1",   // Bottom with display 4.
          "954,599 266x1",  // Bottom with display 5.
      },
      // Display 3 edges.
      {
          "0,600 199x1",    // Top with display 0.
          "199,600 1x300",  // Right with display 4.
          "0,899 199x1",    // Bottom with display 6.
      },
      // Display 4 edges.
      {
          "210,600 416x1",  // Top with display 0.
          "626,600 264x1",  // Top with display 1.
          "890,600 18x1",   // Top with display 2.
          "210,600 1x200",  // Left with display 3.
          "909,600 1x200",  // Right with display 5.
          "210,799 102x1",  // Bottom with display 6.
          "312,799 393x1",  // Bottom with display 7.
          "705,799 203x1",  // Bottom with display 8.
      },
      // Display 5 edges.
      {
          "920,600 350x1",   // Top with display 2.
          "920,600 1x480",   // Left with display 4.
          "920,1079 350x1",  // Bottom with display 8.
      },
      // Display 6 edges.
      {
          "0,1080 169x1",    // Top with display 3.
          "169,1080 130x1",  // Top with display 4.
          "299,1080 1x500",  // Right with display 7.
      },
      // Display 7 edges.
      {
          "310,1080 600x1",  // Top with display 4.
          "310,1080 1x599",  // Left with display 6.
          "909,1080 1x599",  // Right with display 8.
      },
      // Display 8 edges.
      {
          "920,1080 233x1",   // Top with display 4.
          "1153,1080 167x1",  // Top with display 5.
          "920,1080 1x450",   // Left with display 7.
      },
  };

  BoundaryTestBody(display_specs, matrix, expected_edges);

  ASSERT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());

  // Assert mouse warps in all bounds to the correct display.
  const std::vector<WarpGroup> warp_groups = {
      {{499, 10}, {500, 9}, list[1]},     // Display 0 --> 1.
      {{10, 299}, {9, 300}, list[3]},     // Display 0 --> 3.
      {{130, 299}, {129, 300}, list[4]},  // Display 0 --> 4.

      {{510, 10}, {498, 6}, list[0]},     // Display 1 --> 0.
      {{909, 50}, {740, 30}, list[2]},    // Display 1 --> 2.
      {{600, 499}, {553, 300}, list[4]},  // Display 1 --> 4.

      {{920, 50}, {738, 24}, list[1]},    // Display 2 --> 1.
      {{930, 599}, {744, 300}, list[4]},  // Display 2 --> 4.
      {{970, 599}, {764, 300}, list[5]},  // Display 2 --> 5.

      {{10, 600}, {6, 298}, list[0]},     // Display 3 --> 0.
      {{199, 700}, {121, 359}, list[4]},  // Display 3 --> 4.
      {{100, 899}, {59, 482}, list[6]},   // Display 3 --> 6.

      {{250, 600}, {157, 298}, list[0]},  // Display 4 --> 0.
      {{700, 600}, {566, 298}, list[1]},  // Display 4 --> 1.
      {{900, 600}, {748, 299}, list[2]},  // Display 4 --> 2.
      {{210, 700}, {120, 391}, list[3]},  // Display 4 --> 3.
      {{909, 650}, {757, 344}, list[5]},  // Display 4 --> 5.
      {{250, 799}, {156, 482}, list[6]},  // Display 4 --> 6.
      {{500, 799}, {383, 482}, list[7]},  // Display 4 --> 7.
      {{800, 799}, {656, 482}, list[8]},  // Display 4 --> 8.

      {{950, 600}, {768, 299}, list[2]},    // Display 5 --> 2.
      {{920, 750}, {756, 355}, list[4]},    // Display 5 --> 4.
      {{1000, 1079}, {786, 482}, list[8]},  // Display 5 --> 8.

      {{100, 1080}, {70, 480}, list[3]},   // Display 6 --> 3.
      {{200, 1080}, {141, 480}, list[4]},  // Display 6 --> 4.
      {{299, 1200}, {214, 566}, list[7]},  // Display 6 --> 7.

      {{500, 1080}, {326, 480}, list[4]},  // Display 7 --> 4.
      {{310, 1500}, {212, 731}, list[6]},  // Display 7 --> 6.
      {{909, 1500}, {572, 731}, list[8]},  // Display 7 --> 8.

      {{1000, 1080}, {634, 480}, list[4]},  // Display 8 --> 4.
      {{1200, 1080}, {793, 481}, list[5]},  // Display 8 --> 5.
      {{920, 1500}, {570, 814}, list[7]},   // Display 8 --> 7.
  };
  WarpTestBody(warp_groups);
}

// Verifies if the mouse pointer correctly moves to another display in
// unified desktop mode.
TEST_F(UnifiedMouseWarpControllerTest, WarpMouse) {
  UpdateDisplay("600x500,700+0-600x500");
  ASSERT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());

  EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(10, 10)));
  // Touch the right edge of the first display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(599, 10)));
  EXPECT_EQ("601,10",  // by 2px.
            aura::Env::GetInstance()->last_mouse_location().ToString());

  // Touch the left edge of the second display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(700, 10)));
  EXPECT_EQ("598,10",  // by 2px.
            aura::Env::GetInstance()->last_mouse_location().ToString());
  {
    SCOPED_TRACE("1x1 NO WARP");
    NoWarpTestBody();
  }

  // With 2X and 1X displays
  UpdateDisplay("600x500*2,700+0-600x500");
  ASSERT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());

  EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(10, 10)));
  // Touch the right edge of the first display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(599, 10)));
  EXPECT_EQ("300,5",  // moved to 601 by 2px, divided by 2 (dsf).
            aura::Env::GetInstance()->last_mouse_location().ToString());

  // Touch the left edge of the second display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(700, 10)));
  EXPECT_EQ("299,5",  // moved to 598 by 2px, divided by 2 (dsf).
            aura::Env::GetInstance()->last_mouse_location().ToString());

  {
    SCOPED_TRACE("2x1 NO WARP");
    NoWarpTestBody();
  }

  // With 1X and 2X displays
  UpdateDisplay("600x500,700+0-600x500*2");
  ASSERT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());

  EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(10, 10)));
  // Touch the right edge of the first display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(599, 10)));
  EXPECT_EQ("601,10",  // by 2px.
            aura::Env::GetInstance()->last_mouse_location().ToString());

  // Touch the left edge of the second display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(700, 10)));
  EXPECT_EQ("598,10",  // by 2px.
            aura::Env::GetInstance()->last_mouse_location().ToString());
  {
    SCOPED_TRACE("1x2 NO WARP");
    NoWarpTestBody();
  }

  // With two 2X displays
  UpdateDisplay("600x500*2,700+0-600x500*2");
  ASSERT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());

  EXPECT_FALSE(TestIfMouseWarpsAt(gfx::Point(10, 10)));
  // Touch the right edge of the first display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(599, 10)));
  EXPECT_EQ("300,5",  // by 2px.
            aura::Env::GetInstance()->last_mouse_location().ToString());

  // Touch the left edge of the second display. Pointer should warp.
  EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(700, 10)));
  EXPECT_EQ("299,5",  // moved to 598 by 2px, divided by 2 (dsf).
            aura::Env::GetInstance()->last_mouse_location().ToString());
  {
    SCOPED_TRACE("1x2 NO WARP");
    NoWarpTestBody();
  }
}

}  // namespace aura