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

#include "mojo/services/public/cpp/surfaces/surfaces_type_converters.h"

#include "cc/output/compositor_frame.h"
#include "cc/output/delegated_frame_data.h"
#include "cc/quads/draw_quad.h"
#include "cc/quads/render_pass.h"
#include "cc/quads/shared_quad_state.h"
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/surface_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
#include "mojo/services/public/cpp/geometry/geometry_type_converters.h"

namespace mojo {

// static
surfaces::SurfaceIdPtr
TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
    const cc::SurfaceId& input) {
  surfaces::SurfaceIdPtr id(surfaces::SurfaceId::New());
  id->id = input.id;
  return id.Pass();
}

// static
cc::SurfaceId TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertTo(
    const surfaces::SurfaceIdPtr& input) {
  return cc::SurfaceId(input->id);
}

// static
surfaces::ColorPtr TypeConverter<surfaces::ColorPtr, SkColor>::ConvertFrom(
    const SkColor& input) {
  surfaces::ColorPtr color(surfaces::Color::New());
  color->rgba = input;
  return color.Pass();
}

// static
SkColor TypeConverter<surfaces::ColorPtr, SkColor>::ConvertTo(
    const surfaces::ColorPtr& input) {
  return input->rgba;
}

// static
surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
    const cc::DrawQuad& input) {
  surfaces::QuadPtr quad = surfaces::Quad::New();
  quad->material = static_cast<surfaces::Material>(input.material);
  quad->rect = Rect::From(input.rect);
  quad->opaque_rect = Rect::From(input.opaque_rect);
  quad->visible_rect = Rect::From(input.visible_rect);
  quad->needs_blending = input.needs_blending;
  // This is intentionally left set to an invalid value here. It's set when
  // converting an entire pass since it's an index into the pass' shared quad
  // state list.
  quad->shared_quad_state_index = -1;
  switch (input.material) {
    case cc::DrawQuad::SOLID_COLOR: {
      const cc::SolidColorDrawQuad* color_quad =
          cc::SolidColorDrawQuad::MaterialCast(&input);
      surfaces::SolidColorQuadStatePtr color_state =
          surfaces::SolidColorQuadState::New();
      color_state->color = surfaces::Color::From(color_quad->color);
      color_state->force_anti_aliasing_off =
          color_quad->force_anti_aliasing_off;
      quad->solid_color_quad_state = color_state.Pass();
      break;
    }
    case cc::DrawQuad::SURFACE_CONTENT: {
      const cc::SurfaceDrawQuad* surface_quad =
          cc::SurfaceDrawQuad::MaterialCast(&input);
      surfaces::SurfaceQuadStatePtr surface_state =
          surfaces::SurfaceQuadState::New();
      surface_state->surface =
          surfaces::SurfaceId::From(surface_quad->surface_id);
      quad->surface_quad_state = surface_state.Pass();
      break;
    }
    case cc::DrawQuad::TEXTURE_CONTENT: {
      const cc::TextureDrawQuad* texture_quad =
          cc::TextureDrawQuad::MaterialCast(&input);
      surfaces::TextureQuadStatePtr texture_state =
          surfaces::TextureQuadState::New();
      texture_state = surfaces::TextureQuadState::New();
      texture_state->resource_id = texture_quad->resource_id;
      texture_state->premultiplied_alpha = texture_quad->premultiplied_alpha;
      texture_state->uv_top_left = PointF::From(texture_quad->uv_top_left);
      texture_state->uv_bottom_right =
          PointF::From(texture_quad->uv_bottom_right);
      texture_state->background_color =
          surfaces::Color::From(texture_quad->background_color);
      Array<float> vertex_opacity(4);
      for (size_t i = 0; i < 4; ++i) {
        vertex_opacity[i] = texture_quad->vertex_opacity[i];
      }
      texture_state->vertex_opacity = vertex_opacity.Pass();
      texture_state->flipped = texture_quad->flipped;
      quad->texture_quad_state = texture_state.Pass();
      break;
    }
    default:
      NOTREACHED() << "Unsupported material " << input.material;
  }
  return quad.Pass();
}

// static
scoped_ptr<cc::DrawQuad> ConvertTo(const surfaces::QuadPtr& input,
                                   cc::SharedQuadState* sqs) {
  switch (input->material) {
    case surfaces::MATERIAL_SOLID_COLOR: {
      scoped_ptr<cc::SolidColorDrawQuad> color_quad(new cc::SolidColorDrawQuad);
      color_quad->SetAll(
          sqs,
          input->rect.To<gfx::Rect>(),
          input->opaque_rect.To<gfx::Rect>(),
          input->visible_rect.To<gfx::Rect>(),
          input->needs_blending,
          input->solid_color_quad_state->color.To<SkColor>(),
          input->solid_color_quad_state->force_anti_aliasing_off);
      return color_quad.PassAs<cc::DrawQuad>();
    }
    case surfaces::MATERIAL_SURFACE_CONTENT: {
      scoped_ptr<cc::SurfaceDrawQuad> surface_quad(new cc::SurfaceDrawQuad);
      surface_quad->SetAll(
          sqs,
          input->rect.To<gfx::Rect>(),
          input->opaque_rect.To<gfx::Rect>(),
          input->visible_rect.To<gfx::Rect>(),
          input->needs_blending,
          input->surface_quad_state->surface.To<cc::SurfaceId>());
      return surface_quad.PassAs<cc::DrawQuad>();
    }
    case surfaces::MATERIAL_TEXTURE_CONTENT: {
      scoped_ptr<cc::TextureDrawQuad> texture_quad(new cc::TextureDrawQuad);
      surfaces::TextureQuadStatePtr& texture_quad_state =
          input->texture_quad_state;
      texture_quad->SetAll(
          sqs,
          input->rect.To<gfx::Rect>(),
          input->opaque_rect.To<gfx::Rect>(),
          input->visible_rect.To<gfx::Rect>(),
          input->needs_blending,
          texture_quad_state->resource_id,
          texture_quad_state->premultiplied_alpha,
          texture_quad_state->uv_top_left.To<gfx::PointF>(),
          texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
          texture_quad_state->background_color.To<SkColor>(),
          texture_quad_state->vertex_opacity.storage().data(),
          texture_quad_state->flipped);
      return texture_quad.PassAs<cc::DrawQuad>();
    }
    default:
      NOTREACHED() << "Unsupported material " << input->material;
  }
  return scoped_ptr<cc::DrawQuad>();
}

// static
surfaces::SharedQuadStatePtr
TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
    const cc::SharedQuadState& input) {
  surfaces::SharedQuadStatePtr state = surfaces::SharedQuadState::New();
  state->content_to_target_transform =
      Transform::From(input.content_to_target_transform);
  state->content_bounds = Size::From(input.content_bounds);
  state->visible_content_rect = Rect::From(input.visible_content_rect);
  state->clip_rect = Rect::From(input.clip_rect);
  state->is_clipped = input.is_clipped;
  state->opacity = input.opacity;
  state->blend_mode = static_cast<surfaces::SkXfermode>(input.blend_mode);
  state->sorting_context_id = input.sorting_context_id;
  return state.Pass();
}

// static
scoped_ptr<cc::SharedQuadState> ConvertTo(
    const surfaces::SharedQuadStatePtr& input) {
  scoped_ptr<cc::SharedQuadState> state(new cc::SharedQuadState);
  state->SetAll(input->content_to_target_transform.To<gfx::Transform>(),
                input->content_bounds.To<gfx::Size>(),
                input->visible_content_rect.To<gfx::Rect>(),
                input->clip_rect.To<gfx::Rect>(),
                input->is_clipped,
                input->opacity,
                static_cast<SkXfermode::Mode>(input->blend_mode),
                input->sorting_context_id);
  return state.Pass();
}

// static
surfaces::PassPtr TypeConverter<surfaces::PassPtr, cc::RenderPass>::ConvertFrom(
    const cc::RenderPass& input) {
  surfaces::PassPtr pass = surfaces::Pass::New();
  pass->id = input.id.index;
  pass->output_rect = Rect::From(input.output_rect);
  pass->damage_rect = Rect::From(input.damage_rect);
  pass->transform_to_root_target =
      Transform::From(input.transform_to_root_target);
  pass->has_transparent_background = input.has_transparent_background;
  Array<surfaces::QuadPtr> quads(input.quad_list.size());
  Array<surfaces::SharedQuadStatePtr> shared_quad_state(
      input.shared_quad_state_list.size());
  int sqs_i = -1;
  const cc::SharedQuadState* last_sqs = NULL;
  for (size_t i = 0; i < quads.size(); ++i) {
    const cc::DrawQuad& quad = *input.quad_list[i];
    quads[i] = surfaces::Quad::From(quad);
    if (quad.shared_quad_state != last_sqs) {
      sqs_i++;
      shared_quad_state[sqs_i] =
          surfaces::SharedQuadState::From(*input.shared_quad_state_list[i]);
      last_sqs = quad.shared_quad_state;
    }
    quads[i]->shared_quad_state_index = sqs_i;
  }
  // We should copy all shared quad states.
  DCHECK_EQ(static_cast<size_t>(sqs_i + 1), shared_quad_state.size());
  pass->quads = quads.Pass();
  pass->shared_quad_states = shared_quad_state.Pass();
  return pass.Pass();
}

// static
scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
  scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
  pass->SetAll(cc::RenderPass::Id(1, input->id),
               input->output_rect.To<gfx::Rect>(),
               input->damage_rect.To<gfx::Rect>(),
               input->transform_to_root_target.To<gfx::Transform>(),
               input->has_transparent_background);
  cc::SharedQuadStateList& sqs_list = pass->shared_quad_state_list;
  sqs_list.reserve(input->shared_quad_states.size());
  for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
    sqs_list.push_back(ConvertTo(input->shared_quad_states[i]));
  }
  cc::QuadList& quad_list = pass->quad_list;
  quad_list.reserve(input->quads.size());
  for (size_t i = 0; i < input->quads.size(); ++i) {
    surfaces::QuadPtr quad = input->quads[i].Pass();
    quad_list.push_back(
        ConvertTo(quad, sqs_list[quad->shared_quad_state_index]));
  }
  return pass.Pass();
}

// static
surfaces::MailboxPtr
TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertFrom(
    const gpu::Mailbox& input) {
  Array<int8_t> name(64);
  for (int i = 0; i < 64; ++i) {
    name[i] = input.name[i];
  }
  surfaces::MailboxPtr mailbox(surfaces::Mailbox::New());
  mailbox->name = name.Pass();
  return mailbox.Pass();
}

// static
gpu::Mailbox TypeConverter<surfaces::MailboxPtr, gpu::Mailbox>::ConvertTo(
    const surfaces::MailboxPtr& input) {
  gpu::Mailbox mailbox;
  mailbox.SetName(input->name.storage().data());
  return mailbox;
}

// static
surfaces::MailboxHolderPtr
TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertFrom(
    const gpu::MailboxHolder& input) {
  surfaces::MailboxHolderPtr holder(surfaces::MailboxHolder::New());
  holder->mailbox = surfaces::Mailbox::From<gpu::Mailbox>(input.mailbox);
  holder->texture_target = input.texture_target;
  holder->sync_point = input.sync_point;
  return holder.Pass();
}

// static
gpu::MailboxHolder
TypeConverter<surfaces::MailboxHolderPtr, gpu::MailboxHolder>::ConvertTo(
    const surfaces::MailboxHolderPtr& input) {
  gpu::MailboxHolder holder;
  holder.mailbox = input->mailbox.To<gpu::Mailbox>();
  holder.texture_target = input->texture_target;
  holder.sync_point = input->sync_point;
  return holder;
}

// static
surfaces::TransferableResourcePtr TypeConverter<
    surfaces::TransferableResourcePtr,
    cc::TransferableResource>::ConvertFrom(const cc::TransferableResource&
                                               input) {
  surfaces::TransferableResourcePtr transferable =
      surfaces::TransferableResource::New();
  transferable->id = input.id;
  transferable->format = static_cast<surfaces::ResourceFormat>(input.format);
  transferable->filter = input.filter;
  transferable->size = Size::From(input.size);
  transferable->mailbox_holder =
      surfaces::MailboxHolder::From(input.mailbox_holder);
  transferable->is_repeated = input.is_repeated;
  transferable->is_software = input.is_software;
  return transferable.Pass();
}

// static
cc::TransferableResource
TypeConverter<surfaces::TransferableResourcePtr, cc::TransferableResource>::
    ConvertTo(const surfaces::TransferableResourcePtr& input) {
  cc::TransferableResource transferable;
  transferable.id = input->id;
  transferable.format = static_cast<cc::ResourceFormat>(input->format);
  transferable.filter = input->filter;
  transferable.size = input->size.To<gfx::Size>();
  transferable.mailbox_holder = input->mailbox_holder.To<gpu::MailboxHolder>();
  transferable.is_repeated = input->is_repeated;
  transferable.is_software = input->is_software;
  return transferable;
}

// static
Array<surfaces::TransferableResourcePtr>
TypeConverter<Array<surfaces::TransferableResourcePtr>,
              cc::TransferableResourceArray>::
    ConvertFrom(const cc::TransferableResourceArray& input) {
  Array<surfaces::TransferableResourcePtr> resources(input.size());
  for (size_t i = 0; i < input.size(); ++i) {
    resources[i] = surfaces::TransferableResource::From(input[i]);
  }
  return resources.Pass();
}

// static
cc::TransferableResourceArray
TypeConverter<Array<surfaces::TransferableResourcePtr>,
              cc::TransferableResourceArray>::
    ConvertTo(const Array<surfaces::TransferableResourcePtr>& input) {
  cc::TransferableResourceArray resources(input.size());
  for (size_t i = 0; i < input.size(); ++i) {
    resources[i] = input[i].To<cc::TransferableResource>();
  }
  return resources;
}

// static
surfaces::ReturnedResourcePtr
TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertFrom(
    const cc::ReturnedResource& input) {
  surfaces::ReturnedResourcePtr returned = surfaces::ReturnedResource::New();
  returned->id = input.id;
  returned->sync_point = input.sync_point;
  returned->count = input.count;
  returned->lost = input.lost;
  return returned.Pass();
}

// static
cc::ReturnedResource
TypeConverter<surfaces::ReturnedResourcePtr, cc::ReturnedResource>::ConvertTo(
    const surfaces::ReturnedResourcePtr& input) {
  cc::ReturnedResource returned;
  returned.id = input->id;
  returned.sync_point = input->sync_point;
  returned.count = input->count;
  returned.lost = input->lost;
  return returned;
}

// static
Array<surfaces::ReturnedResourcePtr> TypeConverter<
    Array<surfaces::ReturnedResourcePtr>,
    cc::ReturnedResourceArray>::ConvertFrom(const cc::ReturnedResourceArray&
                                                input) {
  Array<surfaces::ReturnedResourcePtr> resources(input.size());
  for (size_t i = 0; i < input.size(); ++i) {
    resources[i] = surfaces::ReturnedResource::From(input[i]);
  }
  return resources.Pass();
}

// static
surfaces::FramePtr
TypeConverter<surfaces::FramePtr, cc::CompositorFrame>::ConvertFrom(
    const cc::CompositorFrame& input) {
  surfaces::FramePtr frame = surfaces::Frame::New();
  DCHECK(input.delegated_frame_data);
  cc::DelegatedFrameData* frame_data = input.delegated_frame_data.get();
  frame->resources =
      Array<surfaces::TransferableResourcePtr>::From(frame_data->resource_list);
  const cc::RenderPassList& pass_list = frame_data->render_pass_list;
  frame->passes = Array<surfaces::PassPtr>::New(pass_list.size());
  for (size_t i = 0; i < pass_list.size(); ++i) {
    frame->passes[i] = surfaces::Pass::From(*pass_list[i]);
  }
  return frame.Pass();
}

// static
scoped_ptr<cc::CompositorFrame> ConvertTo(const surfaces::FramePtr& input) {
  scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
  frame_data->device_scale_factor = 1.f;
  frame_data->resource_list =
      input->resources.To<cc::TransferableResourceArray>();
  frame_data->render_pass_list.reserve(input->passes.size());
  for (size_t i = 0; i < input->passes.size(); ++i) {
    frame_data->render_pass_list.push_back(ConvertTo(input->passes[i]));
  }
  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
  frame->delegated_frame_data = frame_data.Pass();
  return frame.Pass();
}

}  // namespace mojo