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

#include <stdint.h>

#include <sstream>

#include "ppapi/c/pp_errors.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/cpp/graphics_2d.h"
#include "ppapi/cpp/image_data.h"
#include "ppapi/cpp/input_event.h"
#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/module.h"
#include "ppapi/cpp/rect.h"
#include "ppapi/cpp/var.h"
#include "ppapi/utility/completion_callback_factory.h"

// When compiling natively on Windows, PostMessage can be #define-d to
// something else.
#ifdef PostMessage
#undef PostMessage
#endif

// Example plugin to demonstrate usage of pp::View and pp::Graphics2D APIs for
// rendering 2D graphics at device resolution. See Paint() for more details.
class MyInstance : public pp::Instance {
 public:
  explicit MyInstance(PP_Instance instance)
      : pp::Instance(instance),
        width_(0),
        height_(0),
        pixel_width_(0),
        pixel_height_(0),
        device_scale_(1.0f),
        css_scale_(1.0f),
        using_device_pixels_(true) {
    RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE |
                       PP_INPUTEVENT_CLASS_KEYBOARD);
  }

  virtual void DidChangeView(const pp::View& view) {
    pp::Rect view_rect = view.GetRect();
    if (view_rect.width() == width_ &&
        view_rect.height() == height_ &&
        view.GetDeviceScale() == device_scale_ &&
        view.GetCSSScale() == css_scale_)
      return;  // We don't care about the position, only the size and scale.

    width_ = view_rect.width();
    height_ = view_rect.height();
    device_scale_ = view.GetDeviceScale();
    css_scale_ = view.GetCSSScale();

    pixel_width_ = static_cast<int>(width_ * device_scale_);
    pixel_height_ = static_cast<int>(height_ * device_scale_);

    SetupGraphics();
  }

  virtual bool HandleInputEvent(const pp::InputEvent& event) {
    switch (event.GetType()) {
      case PP_INPUTEVENT_TYPE_MOUSEDOWN:
        HandleMouseDown(event);
        return true;
      default:
        return false;
    }
  }

  virtual void HandleMessage(const pp::Var& message_data) {
    if (message_data.is_string()) {
      std::string str = message_data.AsString();
      if (str == "dip") {
        if (using_device_pixels_) {
          using_device_pixels_ = false;
          SetupGraphics();
        }
      } else if (str == "device") {
        if (!using_device_pixels_) {
          using_device_pixels_ = true;
          SetupGraphics();
        }
      } else if (str == "metrics") {
        std::stringstream stream;
        stream << "DIP (" << width_ << ", " << height_ << "), device pixels=("
               << pixel_width_ << ", " << pixel_height_ <<"), device_scale="
               << device_scale_ <<", css_scale=" << css_scale_;
        PostMessage(stream.str());
      }
    }
  }

 private:
  void HandleMouseDown(const pp::InputEvent& event) {
    pp::MouseInputEvent mouse_event(event);
    pp::Point position(mouse_event.GetPosition());
    pp::Point position_device(
        static_cast<int32_t>(position.x() * device_scale_),
        static_cast<int32_t>(position.y() * device_scale_));
    std::stringstream stream;
    stream << "Mousedown at DIP (" << position.x() << ", " << position.y()
           << "), device pixel (" << position_device.x() << ", "
           << position_device.y() << ")";
    if (css_scale_ > 0.0f) {
      pp::Point position_css(static_cast<int32_t>(position.x() / css_scale_),
                             static_cast<int32_t>(position.y() / css_scale_));
      stream << ", CSS pixel (" << position_css.x() << ", " << position_css.y()
             <<")";
    } else {
      stream <<", unknown CSS pixel. css_scale_=" << css_scale_;
    }
    PostMessage(stream.str());
  }

  void SetupGraphics() {
    if (using_device_pixels_) {
      // The plugin will treat 1 pixel in the device context as 1 device pixel.
      // This will set up a properly-sized pp::Graphics2D, and tell Pepper
      // to apply the correct scale so the resulting concatenated scale leaves
      // each pixel in the device context as one on the display device.
      device_context_ = pp::Graphics2D(this,
                                       pp::Size(pixel_width_, pixel_height_),
                                       true);
      if (device_scale_ > 0.0f) {
        // If SetScale is promoted to pp::Graphics2D, the dc_dev constructor
        // can be removed, and this will become the following line instead.
        // device_context_.SetScale(1.0f / device_scale_);
        device_context_.SetScale(1.0f / device_scale_);
      }
    } else {
      // The plugin will treat 1 pixel in the device context as one DIP.
      device_context_ = pp::Graphics2D(this, pp::Size(width_, height_), true);
    }
    BindGraphics(device_context_);
    Paint();
  }

  void Paint() {
    int width = using_device_pixels_ ? pixel_width_ : width_;
    int height = using_device_pixels_ ? pixel_height_ : height_;
    pp::ImageData image(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                        pp::Size(width, height), false);
    if (image.is_null())
      return;

    // Painting here will demonstrate a few techniques:
    // - painting a thin blue box and cross-hatch to show the finest resolution
    // available.
    // - painting a 25 DIP (logical pixel) green circle to show how objects of a
    //  fixed size in DIPs should be scaled if using a high-resolution
    // pp::Graphics2D.
    // - paiting a 50 CSS pixel red circle to show how objects of a fixed size
    // in  CSS pixels should be scaled if using a high-resolution
    // pp::Graphics2D, as well as how to use the GetCSSScale value properly.

    // Painting in "DIP resolution" mode (|using_device_pixels_| false) will
    // demonstrate how unscaled graphics would look, even on a high-DPI device.
    // Painting in "device resolution" mode (|using_device_pixels_| true) will
    // show how scaled graphics would look crisper on a high-DPI device, in
    // comparison to using unscaled graphics. Both modes should look identical
    // when displayed on a non-high-DPI device (window.devicePixelRatio == 1).
    // Toggling between "DIP resolution" mode and "device resolution" mode
    // should not change the sizes of the circles.

    // Changing the browser zoom level should cause the CSS circle to zoom, but
    // not the DIP-sized circle.

    // All painting here does not use any anti-aliasing.
    float circle_1_radius = 25;
    if (using_device_pixels_)
      circle_1_radius *= device_scale_;

    float circle_2_radius = 50 * css_scale_;
    if (using_device_pixels_)
      circle_2_radius *= device_scale_;

    for (int y = 0; y < height; ++y) {
      char* row = static_cast<char*>(image.data()) + (y * image.stride());
      uint32_t* pixel = reinterpret_cast<uint32_t*>(row);
      for (int x = 0; x < width; ++x) {
        int dx = (width / 2) - x;
        int dy = (height / 2) - y;
        float dist_squared = static_cast<float>((dx * dx) + (dy * dy));
        if (x == 0 || y == 0 || x == width - 1 || y == width - 1 || x == y ||
            width - x - 1 == y) {
          *pixel++ = 0xFF0000FF;
        } else if (dist_squared < circle_1_radius * circle_1_radius) {
          *pixel++ = 0xFF00FF00;
        } else if (dist_squared < circle_2_radius * circle_2_radius) {
          *pixel++ = 0xFFFF0000;
        } else {
          *pixel++ = 0xFF000000;
        }
      }
    }

    device_context_.ReplaceContents(&image);
    device_context_.Flush(pp::CompletionCallback(&OnFlush, this));
  }

  static void OnFlush(void* user_data, int32_t result) {}

  pp::Graphics2D device_context_;
  int width_;
  int height_;
  int pixel_width_;
  int pixel_height_;
  float device_scale_;
  float css_scale_;
  bool using_device_pixels_;
};

// This object is the global object representing this plugin library as long as
// it is loaded.
class MyModule : public pp::Module {
 public:
  MyModule() : pp::Module() {}
  virtual ~MyModule() {}

  // Override CreateInstance to create your customized Instance object.
  virtual pp::Instance* CreateInstance(PP_Instance instance) {
    return new MyInstance(instance);
  }
};

namespace pp {

// Factory function for your specialization of the Module object.
Module* CreateModule() {
  return new MyModule();
}

}  // namespace pp