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

#ifndef WINDOW_MANAGER_TEST_LIB_H_
#define WINDOW_MANAGER_TEST_LIB_H_

#include <string>

#include <gtest/gtest.h>
extern "C" {
#include <X11/Xlib.h>
}

#include "base/file_path.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "cros/chromeos_wm_ipc_enums.h"
#include "window_manager/compositor/gl/mock_gl_interface.h"
#include "window_manager/compositor/mock_compositor.h"
#include "window_manager/compositor/real_compositor.h"
#include "window_manager/event_consumer.h"
#include "window_manager/event_loop.h"
#include "window_manager/geometry.h"
#include "window_manager/key_bindings.h"
#include "window_manager/mock_dbus_interface.h"
#include "window_manager/stacking_manager.h"
#include "window_manager/window.h"
#include "window_manager/window_manager.h"
#include "window_manager/wm_ipc.h"
#include "window_manager/x11/mock_x_connection.h"
#include "window_manager/x11/x_types.h"

namespace window_manager {

class Panel;

// Test that two bytes sequences are equal, pretty-printing the difference
// otherwise.  Invoke as:
//
//   EXPECT_PRED_FORMAT3(BytesAreEqual, expected, actual, length);
//
testing::AssertionResult BytesAreEqual(
    const char* expected_expr,
    const char* actual_expr,
    const char* size_expr,
    const unsigned char* expected,
    const unsigned char* actual,
    size_t size);

// Called from tests' main() functions to handle a bunch of boilerplate.
// Its return value should be returned from main().  We initialize the
// flag-parsing code, so if the caller wants to set |log_to_stderr| based
// on a flag, a pointer to the flag's variable should be passed here (e.g.
// |&FLAGS_logtostderr|).
int InitAndRunTests(int* argc, char** argv, bool* log_to_stderr);

// Simple RAII class for creating and deleting a temporary directory.
class ScopedTempDirectory {
 public:
  ScopedTempDirectory();
  ~ScopedTempDirectory();
  const FilePath& path() const { return path_; }

 private:
  FilePath path_;
};

// A basic test that sets up fake X and compositor interfaces and creates a
// WindowManager object.  Also includes several methods that tests can use
// for convenience.
class BasicWindowManagerTest : public ::testing::Test {
 protected:
  virtual void SetUp();

  // Register keycodes corresponding to common keysyms.
  void RegisterCommonKeySyms();

  // Create a new WindowManager object using the existing X connection,
  // compositor, etc. and store it in |wm_|.
  void CreateNewWm();

  // Call CreateNewWm() and then call its Init() method and ensure that it
  // succeeds.
  void CreateAndInitNewWm();

  // Create a basic window with no special type.
  XWindow CreateBasicWindow(const Rect& bounds);

  // Create a toplevel client window with the passed-in position and
  // dimensions.  It has type WINDOW_TYPE_CHROME_TOPLEVEL.
  XWindow CreateToplevelWindow(int tab_count,
                               int selected_tab,
                               const Rect& bounds);

  // Create a snapshot client window with the passed-in position and
  // dimensions and associated parent toplevel window.
  XWindow CreateSnapshotWindow(XWindow parent_xid,
                               int index,
                               const Rect& bounds);

  // Creates a fav icon window for the associated snapshot.
  XWindow CreateFavIconWindow(XWindow snapshot_xid, const Size& size);

  // Creates a title window for the associated snapshot.
  XWindow CreateTitleWindow(XWindow snapshot_xid, const Size& size);

  // Creates a decoration window (favicon or title) for the associated
  // snapshot window.
  XWindow CreateDecorationWindow(XWindow snapshot_xid,
                                 chromeos::WmIpcWindowType type,
                                 const Size& size);

  // Creates a toplevel client window with an arbitrary size.
  XWindow CreateSimpleWindow();

  // Creates a snapshot client window with an arbitrary size.
  // |toplevel_xid| is the id of the associated toplevel window.
  // |index| is the index of the snapshot within the given toplevel
  // window.
  XWindow CreateSimpleSnapshotWindow(XWindow toplevel_xid, int index);

  // Create a panel titlebar or content window.  Muck around with the
  // |*new_panel*| members below to change content window parameters.
  XWindow CreatePanelTitlebarWindow(const Size& size);
  XWindow CreatePanelContentWindow(const Size& size, XWindow titlebar_xid);

  // Create titlebar and content windows for a panel, show them, and return
  // a pointer to the Panel object.
  Panel* CreatePanel(int width, int titlebar_height, int content_height);

  // Simulates a change in the selected tab and tab count in a chrome
  // toplevel window.
  void ChangeTabInfo(XWindow toplevel_xid,
                     int tab_count,
                     int selected_tab,
                     uint32_t timestamp);

  // Make the window manager handle a CreateNotify event and, if the window
  // isn't override-redirect, a MapRequest.  If it's mapped after this
  // (expected if we sent a MapRequest), send a MapNotify event.  After
  // each event, we send a ConfigureNotify if the window manager changed
  // something about the window using a ConfigureWindow request.
  void SendInitialEventsForWindow(XWindow xid);

  // Send UnmapNotify and DestroyWindow events to the window manager.
  void SendUnmapAndDestroyEventsForWindow(XWindow xid);

  // Send a property change notification for the Chrome window type.
  void SendWindowTypeEvent(XWindow xid);

  // Send a WmIpc message.
  void SendWmIpcMessage(const WmIpc::Message& msg);

  // Send a WM_NOTIFY_IPC_VERSION message.
  void SendNotifyIpcVersionMessage(int version);

  // Send a WM_SET_PANEL_STATE message.
  void SendSetPanelStateMessage(Panel* panel, bool expanded);

  // Send a WM_NOTIFY_PANEL_DRAGGED message.
  void SendPanelDraggedMessage(Panel* panel, int x, int y);

  // Send a WM_NOTIFY_PANEL_DRAG_COMPLETE message.
  void SendPanelDragCompleteMessage(Panel* panel);

  // Send a WM_IPC_MESSAGE_WM_SET_LOGIN_STATE message telling the window
  // manager that the login entries should be selectable or not.
  void SendSetLoginStateMessage(bool entries_selectable);

  // Send a key press and release to the given xid.
  void SendKey(XWindow xid,
               KeyBindings::KeyCombo key,
               XTime press_timestamp,
               XTime release_timestamp);

  // Send a _NET_ACTIVE_WINDOW message asking the window manager to focus a
  // window.
  void SendActiveWindowMessage(XWindow xid);

  // Send a message to the window manager asking it to set or unset |state_atom|
  // (e.g. _NET_WM_STATE_MODAL) in |xid|'s _NET_WM_STATE property.
  void SendWmStateMessage(XWindow xid, XAtom state_atom, bool set);

  // Initialize a ConfigureNotify event for |xid|'s current bounds and stacking
  // and pass it to WindowManager::HandleEvent().
  void SendConfigureNotifyEvent(XWindow xid);

  // Set the _CHROME_LOGGED_IN property on the root window to describe
  // whether Chrome is logged in or not, and send a PropertyNotify event to
  // the window manager (if it's non-NULL).
  void SetLoggedInState(bool logged_in);

  // Append an atom to an integer property on a window.
  void AppendAtomToProperty(
      XWindow xid, XAtom property_atom, XAtom atom_to_add);

  // Configure a window to use the _NET_WM_SYNC_REQUEST protocol to
  // synchronize repaints in response to resizes.  Adds the
  // _NET_WM_SYNC_REQUEST hint to the window's WM_PROTOCOLS property and
  // sets its _NET_WM_SYNC_REQUEST_COUNTER property.
  void ConfigureWindowForSyncRequestProtocol(XWindow xid);

  // Send the window manager an event telling it that the alarm that it's
  // using to wait for notification that a client has finished repainting a
  // window has fired.
  void SendSyncRequestProtocolAlarm(XWindow xid);

  // Get the current value of the _NET_ACTIVE_WINDOW property on the root
  // window.
  XWindow GetActiveWindowProperty();

  // Get the number of WM_DELETE_WINDOW messages that have been sent to a
  // window.
  int GetNumDeleteWindowMessagesForWindow(XWindow xid);

  // Get the first WmIpc message of a particular type received by a window.
  // Returns false if no messages of that type were found.
  bool GetFirstWmIpcMessageOfType(XWindow xid,
                                  chromeos::WmIpcMessageType type,
                                  WmIpc::Message* msg_out);

  // Are the passed-in window's composited and client windows stacked
  // between the passed-in layer and the layer underneath it?
  bool WindowIsInLayer(Window* win, StackingManager::Layer layer);

  // Test that |win| is stacked above |other_win| (both in terms of its X and
  // composited windows).  We also return true if this is the case and false
  // otherwise.
  bool TestWindowIsAboveOtherWindow(Window* win, Window* other_win);

  // Is the passed-in client window entirely offscreen?
  bool WindowIsOffscreen(XWindow xid);

  // Fetch an int array property on a window and check that it contains the
  // expected values.  |num_values| is the number of expected values passed
  // as varargs.  Returns true if the expected and actual values match.
  bool TestIntArrayProperty(XWindow xid, XAtom atom, int num_values, ...);

  // Does the property |atom| on |xid| contain |value|?
  bool IntArrayPropertyContains(XWindow xid, XAtom atom, int value);

  // Decode the message from |event| into |msg|.  Returns false on failure.
  bool DecodeWmIpcMessage(const XClientMessageEvent& event,
                          WmIpc::Message* msg_out);

  // Get the mock actor for the passed-in window.
  MockCompositor::TexturePixmapActor* GetMockActorForWindow(Window* win);

  // Return a Rect containing the bounds of the composited window associated
  // with |xid| (which must be currently tracked by the window manager).
  Rect GetCompositedWindowBounds(XWindow xid);

  scoped_ptr<EventLoop> event_loop_;
  scoped_ptr<MockXConnection> xconn_;
  scoped_ptr<MockCompositor> compositor_;
  scoped_ptr<MockDBusInterface> dbus_;
  scoped_ptr<WindowManager> wm_;

  // Settings used for subsequent windows created by
  // CreatePanelContentWindow() and CreatePanel().  These are here so that
  // new parameters can be added without having to update a bunch of
  // testing code (tests for the new parameters can change these settings,
  // while existing tests can just use reasonably-chosen defaults).
  bool new_panels_should_be_expanded_;
  bool new_panels_should_take_focus_;
  XWindow creator_content_xid_for_new_panels_;
  chromeos::WmIpcPanelUserResizeType resize_type_for_new_panels_;
};


// Base class for compositing-related tests.
class BasicCompositingTest : public ::testing::Test {
 public:
  BasicCompositingTest() {}
  virtual ~BasicCompositingTest();

  virtual void SetUp();
  virtual void TearDown() {}

 protected:
  // Call |compositor_|'s Draw() method.
  void Draw();

  scoped_ptr<MockGLInterface> gl_;
  scoped_ptr<MockXConnection> xconn_;
  scoped_ptr<EventLoop> event_loop_;
  scoped_ptr<RealCompositor> compositor_;
};

class BasicCompositingTreeTest : public BasicCompositingTest {
 public:
  BasicCompositingTreeTest() {}
  virtual ~BasicCompositingTreeTest();

  virtual void SetUp();
  virtual void TearDown() { BasicCompositingTest::TearDown(); }

 protected:
  //      stage
  //      |   |
  // group1   group3
  //    |       |
  // group2   group4
  //    |     |    |
  // rect1 rect2  rect3
  //
  // A container (with the exception of the stage)'s depth is further away
  // than that of its children, and earlier-added children within each
  // container will be further away than later-added children.
  //
  // Given the order in which these actors are added in test_lib.cc, the
  // depths (in nearest to furthest order) should be:
  //
  // stage   0
  // rect3   256
  // rect2   (culled)
  // group4  512
  // group3  768
  // rect1   (culled)
  // group2  1024
  // group1  1280
  RealCompositor::StageActor* stage_;
  scoped_ptr<RealCompositor::ContainerActor> group1_;
  scoped_ptr<RealCompositor::ContainerActor> group2_;
  scoped_ptr<RealCompositor::ContainerActor> group3_;
  scoped_ptr<RealCompositor::ContainerActor> group4_;
  scoped_ptr<RealCompositor::ColoredBoxActor> rect1_;
  scoped_ptr<RealCompositor::ColoredBoxActor> rect2_;
  scoped_ptr<RealCompositor::ColoredBoxActor> rect3_;
};


// Simple class that can be used to test callback invocation.
class TestCallbackCounter {
 public:
  TestCallbackCounter() : num_calls_(0) {}
  int num_calls() const { return num_calls_; }
  void Reset() { num_calls_ = 0; }
  void Increment() { num_calls_++; }
 private:
  // Number of times that Increment() has been invoked.
  int num_calls_;
};


class TestEventConsumer : public EventConsumer {
 public:
  TestEventConsumer()
      : EventConsumer(),
        should_return_true_for_map_requests_(false) {
    reset_stats();
  }

  void reset_stats() {
    num_logged_in_state_changes_ = 0;
    num_map_requests_ = 0;
    num_mapped_windows_ = 0;
    num_unmapped_windows_ = 0;
    num_fetched_pixmaps_ = 0;
    num_button_presses_ = 0;
  }

  void set_should_return_true_for_map_requests(bool return_true) {
    should_return_true_for_map_requests_ = return_true;
  }

  int num_logged_in_state_changes() const {
    return num_logged_in_state_changes_;
  }
  int num_map_requests() const { return num_map_requests_; }
  int num_mapped_windows() const { return num_mapped_windows_; }
  int num_unmapped_windows() const { return num_unmapped_windows_; }
  int num_fetched_pixmaps() const { return num_fetched_pixmaps_; }
  int num_button_presses() const { return num_button_presses_; }
  const std::vector<WmIpc::Message>& chrome_messages() const {
    return chrome_messages_;
  }
  const std::set<std::tr1::shared_ptr<DestroyedWindow> >&
      destroyed_windows() const {
    return destroyed_windows_;
  }

  // Begin overridden EventConsumer virtual methods.
  virtual bool IsInputWindow(XWindow xid) { return false; }
  virtual void HandleScreenResize() {}
  virtual void HandleLoggedInStateChange() { num_logged_in_state_changes_++; }
  virtual bool HandleWindowMapRequest(Window* win) {
    num_map_requests_++;
    return should_return_true_for_map_requests_;
  }
  virtual void HandleWindowMap(Window* win) { num_mapped_windows_++; }
  virtual void HandleWindowUnmap(Window* win) { num_unmapped_windows_++; }
  virtual void HandleWindowPixmapFetch(Window* win) {
    num_fetched_pixmaps_++;
  }
  virtual void HandleWindowConfigureRequest(Window* win,
                                            const Rect& requested_bounds) {}
  virtual void HandleButtonPress(XWindow xid,
                                 const Point& relative_pos,
                                 const Point& absolute_pos,
                                 int button,
                                 XTime timestamp) {
    num_button_presses_++;
  }
  virtual void HandleButtonRelease(XWindow xid,
                                   const Point& relative_pos,
                                   const Point& absolute_pos,
                                   int button,
                                   XTime timestamp) {}
  virtual void HandlePointerEnter(XWindow xid,
                                  const Point& relative_pos,
                                  const Point& absolute_pos,
                                  XTime timestamp) {}
  virtual void HandlePointerLeave(XWindow xid,
                                  const Point& relative_pos,
                                  const Point& absolute_pos,
                                  XTime timestamp) {}
  virtual void HandlePointerMotion(XWindow xid,
                                   const Point& relative_pos,
                                   const Point& absolute_pos,
                                   XTime timestamp) {}
  virtual void HandleChromeMessage(const WmIpc::Message& msg) {
    chrome_messages_.push_back(msg);
  }
  virtual void HandleClientMessage(XWindow xid,
                                   XAtom message_type,
                                   const long data[5]) {}
  virtual void HandleFocusChange(XWindow xid, bool focus_in) {}
  virtual void HandleWindowPropertyChange(XWindow xid, XAtom xatom) {}
  virtual void OwnDestroyedWindow(DestroyedWindow* destroyed_win, XWindow xid) {
    destroyed_windows_.insert(
        std::tr1::shared_ptr<DestroyedWindow>(destroyed_win));
  }
  // End overridden EventConsumer virtual methods.

 private:
  // Should we return true when HandleWindowMapRequest() is invoked?
  bool should_return_true_for_map_requests_;

  int num_logged_in_state_changes_;
  int num_map_requests_;
  int num_mapped_windows_;
  int num_unmapped_windows_;
  int num_fetched_pixmaps_;
  int num_button_presses_;

  // Messages received via HandleChromeMessage().
  std::vector<WmIpc::Message> chrome_messages_;

  // DestroyedWindow objects that WindowManager has given to us.
  std::set<std::tr1::shared_ptr<DestroyedWindow> > destroyed_windows_;
};

}  // namespace window_manager

#endif  // WINDOW_MANAGER_TEST_LIB_H_