// Licensed to the Software Freedom Conservancy (SFC) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The SFC licenses this file
// to you under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "ScreenshotCommandHandler.h"
#include <atlenc.h>
#include <atlimage.h>
#include "errorcodes.h"
#include "logging.h"
#include "../Browser.h"
#include "../IECommandExecutor.h"

namespace webdriver {

ScreenshotCommandHandler::ScreenshotCommandHandler(void) {
  this->image_ = NULL;
}

ScreenshotCommandHandler::~ScreenshotCommandHandler(void) {
}

void ScreenshotCommandHandler::ExecuteInternal(
    const IECommandExecutor& executor,
    const ParametersMap& command_parameters,
    Response* response) {
  LOG(TRACE) << "Entering ScreenshotCommandHandler::ExecuteInternal";

  BrowserHandle browser_wrapper;
  int status_code = executor.GetCurrentBrowser(&browser_wrapper);
  if (status_code != WD_SUCCESS) {
    response->SetErrorResponse(status_code, "Unable to get browser");
    return;
  }

  status_code = this->GenerateScreenshotImage(browser_wrapper);
  if (status_code != WD_SUCCESS) {
    // TODO: Return a meaningful error here.
    response->SetSuccessResponse("");
    return;
  }

  // now either correct or single color image is got
  std::string base64_screenshot = "";
  HRESULT hr = this->GetBase64Data(base64_screenshot);
  if (FAILED(hr)) {
    // TODO: Return a meaningful error here.
    LOGHR(WARN, hr) << "Unable to transform browser image to Base64 format";
    this->ClearImage();
    response->SetSuccessResponse("");
    return;
  }

  this->ClearImage();
  response->SetSuccessResponse(base64_screenshot);
}

int ScreenshotCommandHandler::GenerateScreenshotImage(BrowserHandle browser_wrapper) {
  bool is_same_colour = true;
  HRESULT hr;
  int i = 0;
  int tries = 4;
  do {
    this->ClearImage();

    this->image_ = new CImage();
    hr = this->CaptureViewport(browser_wrapper);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Failed to capture browser image at " << i << " try";
      this->ClearImage();
      return EUNHANDLEDERROR;
    }

    is_same_colour = IsSameColour();
    if (is_same_colour) {
      ::Sleep(2000);
      LOG(DEBUG) << "Failed to capture non single color browser image at " << i << " try";
    }

    ++i;
  } while ((i < tries) && is_same_colour);
  return WD_SUCCESS;
}

void ScreenshotCommandHandler::ClearImage() {
  if (this->image_ != NULL) {
    delete this->image_;
    this->image_ = NULL;
  }
}

HRESULT ScreenshotCommandHandler::CaptureViewport(BrowserHandle browser) {
  LOG(TRACE) << "Entering ScreenshotCommandHandler::CaptureViewport";

  HWND content_window_handle = browser->GetContentWindowHandle();
  int content_width = 0, content_height = 0;

  this->GetWindowDimensions(content_window_handle, &content_width, &content_height);
  this->CaptureWindow(content_window_handle, content_width, content_height);

  return S_OK;
}

void ScreenshotCommandHandler::CaptureWindow(HWND window_handle,
                                              long width,
                                              long height) {
  // Capture the window's canvas to a DIB.
  // If there are any scroll bars in the window, they should
  // be explicitly cropped out of the image, because of the
  // size of image we are creating..
  BOOL created = this->image_->Create(width, height, /*numbers of bits per pixel = */ 32);
  if (!created) {
    LOG(WARN) << "Unable to initialize image object";
  }
  HDC device_context_handle = this->image_->GetDC();

  BOOL print_result = ::PrintWindow(window_handle,
                                    device_context_handle,
                                    PW_CLIENTONLY);
  if (!print_result) {
    LOG(WARN) << "PrintWindow API is not able to get content window screenshot";
  }

  this->image_->ReleaseDC();
}

bool ScreenshotCommandHandler::IsSameColour() {
  int bytes_per_pixel = this->image_->GetBPP() / 8;
  if (bytes_per_pixel >= 3) {
    BYTE* root_pixel_pointer = reinterpret_cast<BYTE*>(this->image_->GetBits());
    int pitch = this->image_->GetPitch();
    int first_pixel_red = *(root_pixel_pointer);
    int first_pixel_green = *(root_pixel_pointer + 1);
    int first_pixel_blue = *(root_pixel_pointer + 2);

    for (int i = 0; i < this->image_->GetWidth(); ++i) {
      for (int j = 0; j < this->image_->GetHeight(); ++j) {
        int current_pixel_offset = (pitch * j) + (bytes_per_pixel * i);
        int current_pixel_red = *(root_pixel_pointer + current_pixel_offset);
        int current_pixel_green = *(root_pixel_pointer + current_pixel_offset + 1);
        int current_pixel_blue = *(root_pixel_pointer + current_pixel_offset + 2);
        if (first_pixel_red != current_pixel_red ||
            first_pixel_green != current_pixel_green ||
            first_pixel_blue != current_pixel_blue) {
          return false;
        }
      }
    }
  } else {
    COLORREF firstPixelColour = this->image_->GetPixel(0, 0);
    for (int i = 0; i < this->image_->GetWidth(); ++i) {
      for (int j = 0; j < this->image_->GetHeight(); ++j) {
        if (this->image_->GetPixel(i, j)) {
          return false;
        }
      }
    }
  }

  return true;
}

HRESULT ScreenshotCommandHandler::GetBase64Data(std::string& data) {
  LOG(TRACE) << "Entering ScreenshotCommandHandler::GetBase64Data";

  if (this->image_ == NULL) {
    LOG(DEBUG) << "CImage was not initialized.";
    return E_POINTER;
  }

  CComPtr<IStream> stream;
  HRESULT hr = ::CreateStreamOnHGlobal(NULL, TRUE, &stream);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Error is occured during creating IStream";
    return hr;
  }

  GUID image_format = Gdiplus::ImageFormatPNG /*Gdiplus::ImageFormatJPEG*/;
  hr = this->image_->Save(stream, image_format);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Saving screenshot image is failed";
    return hr;
  }

  // Get the size of the stream.
  STATSTG statstg;
  hr = stream->Stat(&statstg, STATFLAG_DEFAULT);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "No stat on stream is got";
    return hr;
  }

  HGLOBAL global_memory_handle = NULL;
  hr = ::GetHGlobalFromStream(stream, &global_memory_handle);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "No HGlobal in stream";
    return hr;
  }

  // TODO: What if the file is bigger than max_int?
  int stream_size = static_cast<int>(statstg.cbSize.QuadPart);
  LOG(DEBUG) << "Size of screenshot image stream is " << stream_size;

  int length = ::Base64EncodeGetRequiredLength(stream_size, ATL_BASE64_FLAG_NOCRLF);
  if (length <= 0) {
    LOG(WARN) << "Got zero or negative length from base64 required length";
    return E_FAIL;
  }

  BYTE* global_lock = reinterpret_cast<BYTE*>(::GlobalLock(global_memory_handle));
  if (global_lock == NULL) {
    LOGERR(WARN) << "Unable to lock memory for base64 encoding";
    ::GlobalUnlock(global_memory_handle);      
    return E_FAIL;
  }

  char* data_array = new char[length + 1];
  if (!::Base64Encode(global_lock,
                      stream_size,
                      data_array,
                      &length,
                      ATL_BASE64_FLAG_NOCRLF)) {
    delete[] data_array;
    ::GlobalUnlock(global_memory_handle);
    LOG(WARN) << "Unable to encode image stream to base64";
    return E_FAIL;
  }
  data_array[length] = '\0';
  data = data_array;

  delete[] data_array;
  ::GlobalUnlock(global_memory_handle);

  return S_OK;
}

void ScreenshotCommandHandler::GetWindowDimensions(HWND window_handle,
                                                    int* width,
                                                    int* height) {
  RECT window_rect;
  ::GetWindowRect(window_handle, &window_rect);
  *width = window_rect.right - window_rect.left;
  *height = window_rect.bottom - window_rect.top;
}

void ScreenshotCommandHandler::CropImage(HWND content_window_handle,
                                         LocationInfo element_location) {
  RECT viewport_rect;
  ::GetWindowRect(content_window_handle, &viewport_rect);
  ::OffsetRect(&viewport_rect,
               -1 * viewport_rect.left,
               -1 * viewport_rect.top);

  POINT element_rect_origin;
  element_rect_origin.x = element_location.x;
  element_rect_origin.y = element_location.y;

  RECT element_rect = { element_rect_origin.x, 
                        element_rect_origin.y,
                        element_rect_origin.x + element_location.width,
                        element_rect_origin.y + element_location.height };

  RECT screenshot_rect;
  ::IntersectRect(&screenshot_rect, &viewport_rect, &element_rect);

  long width = screenshot_rect.right - screenshot_rect.left;
  long height = screenshot_rect.bottom - screenshot_rect.top;

  RECT destination_rect = { 0, 0, width, height };

  CImage* image = new CImage();
  image->Create(width, height, 32);
  HDC device_context = image->GetDC();
  this->image_->Draw(device_context, destination_rect, screenshot_rect);
  image->ReleaseDC();

  this->ClearImage();
  this->image_ = new CImage();
  this->image_->Create(width, height, 32);
  HDC dc = this->image_->GetDC();
  image->BitBlt(dc, 0, 0);
  this->image_->ReleaseDC();
  image->Destroy();
  delete image;
}

} // namespace webdriver