/*
 * Copyright (C) 2016 Simon Fels <morphis@gravedo.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 3, as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

// Both includes need to go first as otherwise they can conflict with EGL.h
// being included by the following includes.
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "anbox/application/database.h"
#include "anbox/platform/base_platform.h"
#include "anbox/wm/multi_window_manager.h"
#include "anbox/wm/window_state.h"

#include "anbox/graphics/layer_composer.h"
#include "anbox/graphics/multi_window_composer_strategy.h"

using namespace ::testing;

namespace {
class MockRenderer : public anbox::graphics::Renderer {
 public:
  MOCK_METHOD3(draw, bool(EGLNativeWindowType, const anbox::graphics::Rect&,
                          const RenderableList&));
};
}

namespace anbox {
namespace graphics {
TEST(LayerComposer, FindsNoSuitableWindowForLayer) {
  auto renderer = std::make_shared<MockRenderer>();

  platform::Configuration config;
  // The default policy will create a dumb window instance when requested
  // from the manager.
  auto platform = platform::create(std::string(), nullptr, config);
  auto app_db = std::make_shared<application::Database>();
  auto wm = std::make_shared<wm::MultiWindowManager>(platform, nullptr, app_db);

  auto single_window = wm::WindowState{
      wm::Display::Id{1},
      true,
      graphics::Rect{0, 0, 1024, 768},
      "org.anbox.test.1",
      wm::Task::Id{1},
      wm::Stack::Id::Freeform,
  };

  wm->apply_window_state_update({single_window}, {});

  LayerComposer composer(renderer, std::make_shared<MultiWindowComposerStrategy>(wm));

  // A single renderable which has a different task id then the window we know
  // about
  RenderableList renderables = {
      {"org.anbox.surface.2", 0, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
  };

  // The renderer should not be called for a layer which doesn't exist
  EXPECT_CALL(*renderer, draw(_, _, _)).Times(0);

  composer.submit_layers(renderables);
}

TEST(LayerComposer, MapsLayersToWindows) {
  auto renderer = std::make_shared<MockRenderer>();

  platform::Configuration config;
  // The default policy will create a dumb window instance when requested
  // from the manager.
  auto platform = platform::create(std::string(), nullptr, config);
  auto app_db = std::make_shared<application::Database>();
  auto wm = std::make_shared<wm::MultiWindowManager>(platform, nullptr, app_db);

  auto first_window = wm::WindowState{
      wm::Display::Id{1},
      true,
      graphics::Rect{0, 0, 1024, 768},
      "org.anbox.foo",
      wm::Task::Id{1},
      wm::Stack::Id::Freeform,
  };

  auto second_window = wm::WindowState{
      wm::Display::Id{1},
      true,
      graphics::Rect{300, 400, 1324, 1168},
      "org.anbox.bar",
      wm::Task::Id{2},
      wm::Stack::Id::Freeform,
  };

  wm->apply_window_state_update({first_window, second_window}, {});

  LayerComposer composer(renderer, std::make_shared<MultiWindowComposerStrategy>(wm));

  // A single renderable which has a different task id then the window we know
  // about
  RenderableList renderables = {
      {"org.anbox.surface.1", 0, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
      {"org.anbox.surface.2", 1, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
  };

  RenderableList first_window_renderables{
      {"org.anbox.surface.1", 0, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
  };

  RenderableList second_window_renderables{
      {"org.anbox.surface.2", 1, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
  };

  EXPECT_CALL(*renderer, draw(_, Rect{0, 0, first_window.frame().width(),
                                      first_window.frame().height()},
                              first_window_renderables))
      .Times(1)
      .WillOnce(Return(true));
  EXPECT_CALL(*renderer, draw(_, Rect{0, 0, second_window.frame().width(),
                                      second_window.frame().height()},
                              second_window_renderables))
      .Times(1)
      .WillOnce(Return(true));

  composer.submit_layers(renderables);
}

TEST(LayerComposer, WindowPartiallyOffscreen) {
  auto renderer = std::make_shared<MockRenderer>();

  platform::Configuration config;
  // The default policy will create a dumb window instance when requested
  // from the manager.
  auto platform = platform::create(std::string(), nullptr, config);
  auto app_db = std::make_shared<application::Database>();
  auto wm = std::make_shared<wm::MultiWindowManager>(platform, nullptr, app_db);

  auto window = wm::WindowState{
      wm::Display::Id{1},
      true,
      graphics::Rect{-100, -100, 924, 668},
      "org.anbox.foo",
      wm::Task::Id{1},
      wm::Stack::Id::Freeform,
  };

  wm->apply_window_state_update({window}, {});

  LayerComposer composer(renderer, std::make_shared<MultiWindowComposerStrategy>(wm));

  // Window is build out of two layers where one is placed inside the other
  // but the layer covering the whole window is placed with its top left
  // origin outside of the visible display area.
  RenderableList renderables = {
    {"org.anbox.surface.1", 0, 1.0f, {-100, -100, 924, 668}, {0, 0, 1024, 768}},
    {"org.anbox.surface.1", 1, 1.0f, {0, 0, 100, 200}, {0, 0, 100, 200}},
  };

  RenderableList expected_renderables{
    {"org.anbox.surface.1", 0, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
    {"org.anbox.surface.1", 1, 1.0f, {100, 100, 200, 300}, {0, 0, 100, 200}},
  };

  EXPECT_CALL(*renderer, draw(_, Rect{0, 0,
                                      window.frame().width(),
                                      window.frame().height()},
                              expected_renderables))
      .Times(1)
      .WillOnce(Return(true));

  composer.submit_layers(renderables);
}

TEST(LayerComposer, PopupShouldNotCauseWindowLayerOffset) {
  auto renderer = std::make_shared<MockRenderer>();

  platform::Configuration config;
  // The default policy will create a dumb window instance when requested
  // from the manager.
  auto platform = platform::create(std::string(), nullptr, config);
  auto app_db = std::make_shared<application::Database>();
  auto wm = std::make_shared<wm::MultiWindowManager>(platform, nullptr, app_db);

  auto window = wm::WindowState{
      wm::Display::Id{1},
      true,
      graphics::Rect{1120, 270, 2144, 1038},
      "org.anbox.foo",
      wm::Task::Id{3},
      wm::Stack::Id::Freeform,
  };

  wm->apply_window_state_update({window}, {});

  LayerComposer composer(renderer, std::make_shared<MultiWindowComposerStrategy>(wm));

  // Having two renderables where the second smaller one overlaps the bigger
  // one and goes a bit offscreen. This should be still placed correctly and
  // the small layer should go offscreen as it is supposed to. This typically
  // happens when a popup window appears which has a shadow attached which goes
  // out of the window area. In our case this is not possible as the area the
  // window has available is static.
  RenderableList renderables = {
    {"org.anbox.surface.3", 0, 1.0f, {1120,270,2144,1038}, {0, 0, 1024, 768}},
    {"org.anbox.surface.3", 1, 1.0f, {1904, 246, 2164, 406}, {0, 0, 260, 160}},
  };

  RenderableList expected_renderables{
    {"org.anbox.surface.3", 0, 1.0f, {0, 0, 1024, 768}, {0, 0, 1024, 768}},
    {"org.anbox.surface.3", 1, 1.0f, {784, -24, 1044, 136}, {0, 0, 260, 160}},
  };

  EXPECT_CALL(*renderer, draw(_, Rect{0, 0,
                                      window.frame().width(),
                                      window.frame().height()},
                              expected_renderables))
      .Times(1)
      .WillOnce(Return(true));

  composer.submit_layers(renderables);
}

}  // namespace graphics
}  // namespace anbox