// Copyright 2018 Google LLC
//
// Licensed 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
//
//     https://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 "tools/render/trace_renderer.h"

#include "tools/render/layout_constants.h"

namespace quic_trace {
namespace render {

namespace {

// Passthrough vector shader.
const char* kVertexShader = R"(
in vec4 coord;
void main(void) {
  gl_Position = vec4(coord);
}
)";

// The geometry shader that accepts a packet represented as a 4-tuple of format
// (time, offset, size, kind) and represents it as a square, assigning
// appropriate color in process.
const char* kGeometryShader = R"(
uniform float distance_scale;
uniform vec2 margin;
uniform int highlighted_packet;

const float kSentPacketDurationMs = 1000;
const vec4 kUnit = vec4(1,1,1,1);

out vec4 v_color;

layout(points) in;
layout(triangle_strip, max_vertices = 4) out;

vec2 norm(vec2 x) {
  return x * 2 - vec2(1, 1);
}

vec4 mapPoint(float x, float y) {
  vec2 point = vec2(x, y);
  point = norm((point - program_state.offset) / program_state.viewport);
  return vec4(point * margin, 0, 1);
}

void main(void) {
  float time = gl_in[0].gl_Position[0];
  float offset = gl_in[0].gl_Position[1];
  float size = gl_in[0].gl_Position[2];
  float kind = gl_in[0].gl_Position[3];

  // Sent is blue.
  v_color = vec4(0.0, 0.0, 0.6, 1.0);
  // Ack is green.
  if (kind <= -1) {
    v_color = vec4(0.0, 0.6, 0.0, 1.0);
  }
  // Lost is red.
  if (kind <= -2) {
    v_color = vec4(0.8, 0.0, 0.0, 1.0);
  }
  // App-limited is orange.
  if (kind <= -3) {
    v_color = vec4(1.0, 0.425, 0.0, 1.0);
  }
  // Highlight the specified packet by making it brighter.
  if (highlighted_packet == gl_PrimitiveIDIn) {
    v_color = kUnit - (kUnit - v_color) * 0.3;
  }

  float duration = distance_scale * kSentPacketDurationMs;
  size *= distance_scale;

  gl_Position = mapPoint(time, offset);
  EmitVertex();

  gl_Position = mapPoint(time + duration, offset);
  EmitVertex();

  gl_Position = mapPoint(time, offset + size);
  EmitVertex();

  gl_Position = mapPoint(time + duration, offset + size);
  EmitVertex();

  EndPrimitive();
}
)";

// A passthrough fragment shader.
const char* kFragmentShader = R"(
in vec4 v_color;
out vec4 color;
void main(void) {
  color = v_color;
}
)";

float PacketTypeToFloat(PacketType type) {
  switch (type) {
    case PacketType::SENT:
      return 0;
    case PacketType::ACKED:
      return -1;
    case PacketType::LOST:
      return -2;
    case PacketType::APP_LIMITED:
      return -3;
  }
}
}  // namespace

TraceRenderer::TraceRenderer(const ProgramState* state)
    : state_(state), shader_(kVertexShader, kGeometryShader, kFragmentShader) {}

void TraceRenderer::PacketCountHint(size_t count) {
  DCHECK(!buffer_ready_);
  packet_buffer_.reserve(count);
}

void TraceRenderer::AddPacket(uint64_t time,
                              uint64_t offset,
                              uint64_t size,
                              PacketType type) {
  DCHECK(!buffer_ready_);
  packet_buffer_.push_back(
      Packet{static_cast<float>(time), static_cast<float>(offset),
             static_cast<float>(size), PacketTypeToFloat(type)});
  max_x_ = std::max(max_x_, time + kSentPacketDurationMs);
  max_y_ = std::max(max_y_, static_cast<float>(offset + size));
}

void TraceRenderer::FinishPackets() {
  glBindBuffer(GL_ARRAY_BUFFER, *buffer_);
  glBufferData(GL_ARRAY_BUFFER,
               sizeof(*packet_buffer_.data()) * packet_buffer_.size(),
               packet_buffer_.data(), GL_STATIC_DRAW);

  packet_count_ = packet_buffer_.size();
  packet_buffer_.clear();
  buffer_ready_ = true;
}

void TraceRenderer::Render() {
  DCHECK(buffer_ready_);
  glUseProgram(*shader_);
  glBindVertexArray(*array_);
  glBindBuffer(GL_ARRAY_BUFFER, *buffer_);

  // Distance scaling.
  // When packets are sufficiently far, they might get smaller than one pixel;
  // that makes rendering look noisy and useless.  Scale them back to ensure
  // they take up at least a pixel on X axis.  Note that we're actually scaling
  // to 1.1 pixels in order to avoid jitter caused by edge cases when zooming.
  float distance_scale = 1.f;
  float packet_size_in_pixels =
      kSentPacketDurationMs / state_->viewport().x * state_->window().x;
  if (packet_size_in_pixels < 1.1f) {
    distance_scale = 1.1f / packet_size_in_pixels;
  }

  const vec2 margin = TraceMargin(state_->dpi_scale());
  const vec2 margin_scale = vec2(1.f, 1.f) - 2 * margin / state_->window();
  state_->Bind(shader_);
  shader_.SetUniform("distance_scale", distance_scale);
  shader_.SetUniform("margin", margin_scale.x, margin_scale.y);
  shader_.SetUniform("highlighted_packet", highlighted_packet_);

  GlVertexArrayAttrib coord(shader_, "coord");
  glVertexAttribPointer(*coord, 4, GL_FLOAT, GL_FALSE, 0, 0);

  const vec2 render_size = state_->window() - 2 * margin;
  glEnable(GL_SCISSOR_TEST);
  glScissor(margin.x, margin.y, render_size.x, render_size.y);
  glDrawArrays(GL_POINTS, 0, packet_count_);
  glDisable(GL_SCISSOR_TEST);
}

}  // namespace render
}  // namespace quic_trace